Verifies values of objects/variables related to AUT calls Class: org.apache.ambari.funtest.server.tests.DeleteServiceTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier clusterServiceEntities=clusterServiceDAO.findAll();
assertEquals(clusterServiceEntities.size(),1);
assertEquals(clusterServiceEntities.get(0).getServiceName(),serviceName);
ClusterServiceEntity clusterServiceEntity=clusterServiceEntities.get(0);
long clusterId=clusterServiceEntity.getClusterId();
ServiceDesiredStateDAO serviceDesiredStateDAO=injector.getInstance(ServiceDesiredStateDAO.class);
List serviceDesiredStateEntities=serviceDesiredStateDAO.findAll();
assertEquals(serviceDesiredStateEntities.size(),1);
ServiceDesiredStateEntity serviceDesiredStateEntity=serviceDesiredStateEntities.get(0);
assertEquals(serviceDesiredStateEntity.getServiceName(),serviceName);
assertEquals(serviceDesiredStateEntity.getDesiredState(),State.INSTALLED);
ServiceComponentDesiredStateDAO serviceComponentDesiredStateDAO=injector.getInstance(ServiceComponentDesiredStateDAO.class);
List serviceComponentDesiredStateEntities=serviceComponentDesiredStateDAO.findAll();
assertEquals(serviceComponentDesiredStateEntities.size(),3);
for ( ServiceComponentDesiredStateEntity serviceComponentDesiredStateEntity : serviceComponentDesiredStateEntities) {
assertEquals(serviceComponentDesiredStateEntity.getDesiredState(),State.INSTALLED);
}
HostComponentStateDAO hostComponentStateDAO=injector.getInstance(HostComponentStateDAO.class);
List hostComponentStateEntities=hostComponentStateDAO.findAll();
assertEquals(hostComponentStateEntities.size(),3);
HostComponentDesiredStateDAO hostComponentDesiredStateDAO=injector.getInstance(HostComponentDesiredStateDAO.class);
List hostComponentDesiredStateEntities=hostComponentDesiredStateDAO.findAll();
assertEquals(hostComponentDesiredStateEntities.size(),3);
jsonResponse=RestApiUtils.executeRequest(new DeleteServiceWebRequest(params,clusterName,serviceName));
WebResponse webResponse=new GetServiceWebRequest(params,clusterName,serviceName).getResponse();
assertEquals(webResponse.getStatusCode(),HttpStatus.SC_NOT_FOUND);
clusterServiceEntity=clusterServiceDAO.findByClusterAndServiceNames(clusterName,serviceName);
assertTrue(clusterServiceEntity == null);
ServiceDesiredStateEntityPK serviceDesiredStateEntityPK=injector.getInstance(ServiceDesiredStateEntityPK.class);
serviceDesiredStateEntityPK.setClusterId(clusterId);
serviceDesiredStateEntityPK.setServiceName(serviceName);
serviceDesiredStateEntity=serviceDesiredStateDAO.findByPK(serviceDesiredStateEntityPK);
assertTrue(serviceDesiredStateEntity == null);
ServiceComponentDesiredStateEntityPK serviceComponentDesiredStateEntityPK=injector.getInstance(ServiceComponentDesiredStateEntityPK.class);
ServiceComponentDesiredStateEntity serviceComponentDesiredStateEntity=serviceComponentDesiredStateDAO.findByPK(serviceComponentDesiredStateEntityPK);
assertTrue(serviceComponentDesiredStateEntity == null);
hostComponentStateEntities=hostComponentStateDAO.findByService(serviceName);
assertEquals(hostComponentStateEntities.size(),0);
hostComponentDesiredStateEntities=hostComponentDesiredStateDAO.findAll();
assertEquals(hostComponentDesiredStateEntities.size(),0);
jsonResponse=RestApiUtils.executeRequest(new DeleteClusterWebRequest(params,clusterName));
LOG.info(jsonResponse);
}
Class: org.apache.ambari.funtest.server.tests.GetStacksTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.funtest.server.tests.RoleBasedAccessControlBasicTest APIUtilityVerifier InternalCallVerifier EqualityVerifier (){
{
put("fs.default.name","localhost:9995");
}
}
);
ConnectionParams anonUserParams=createConnectionParams(anonUserName,anonUserPwd);
WebRequest webRequest=new CreateConfigurationWebRequest(anonUserParams,configParams);
WebResponse webResponse=webRequest.getResponse();
assertEquals(HttpStatus.SC_FORBIDDEN,webResponse.getStatusCode());
JsonElement jsonResponse=RestApiUtils.executeRequest(new DeleteUserWebRequest(adminConnectionParams,"nothing"));
LOG.info(jsonResponse);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier (){
{
put("fs.default.name","localhost:9995");
}
}
);
ConnectionParams userConnectionParams=createConnectionParams(clusterAdminName,clusterAdminPwd);
WebRequest webRequest=new CreateConfigurationWebRequest(userConnectionParams,configParams);
WebResponse webResponse=webRequest.getResponse();
assertEquals(HttpStatus.SC_CREATED,webResponse.getStatusCode());
RestApiUtils.executeRequest(new DeleteUserWebRequest(adminConnectionParams,clusterAdminName));
}
Class: org.apache.ambari.msi.ClusterDefinitionTest InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier hosts=clusterDefinition.getHosts();
Assert.assertTrue(hosts.contains("NAMENODE_MASTER.acme.com"));
Assert.assertTrue(hosts.contains("SECONDARY_NAMENODE_MASTER.acme.com"));
Assert.assertTrue(hosts.contains("FLUME_SERVICE1.acme.com"));
Assert.assertTrue(hosts.contains("FLUME_SERVICE2.acme.com"));
Assert.assertTrue(hosts.contains("FLUME_SERVICE3.acme.com"));
Assert.assertTrue(hosts.contains("HBASE_MASTER.acme.com"));
Assert.assertTrue(hosts.contains("HIVE_SERVER_MASTER.acme.com"));
Assert.assertTrue(hosts.contains("JOBTRACKER_MASTER.acme.com"));
Assert.assertTrue(hosts.contains("OOZIE_SERVER_MASTER.acme.com"));
Assert.assertTrue(hosts.contains("slave1.acme.com"));
Assert.assertTrue(hosts.contains("slave2.acme.com"));
Assert.assertTrue(hosts.contains("slave3.acme.com"));
Assert.assertTrue(hosts.contains("WEBHCAT_MASTER.acme.com"));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier components=clusterDefinition.getComponents("HDFS");
Assert.assertTrue(components.contains("NAMENODE"));
Assert.assertTrue(components.contains("SECONDARY_NAMENODE"));
Assert.assertTrue(components.contains("DATANODE"));
components=clusterDefinition.getComponents("MAPREDUCE");
Assert.assertTrue(components.contains("JOBTRACKER"));
Assert.assertTrue(components.contains("TASKTRACKER"));
components=clusterDefinition.getComponents("FLUME");
Assert.assertTrue(components.contains("FLUME_SERVER"));
components=clusterDefinition.getComponents("OOZIE");
Assert.assertTrue(components.contains("OOZIE_SERVER"));
components=clusterDefinition.getComponents("HBASE");
Assert.assertTrue(components.contains("HBASE_MASTER"));
Assert.assertTrue(components.contains("HBASE_REGIONSERVER"));
components=clusterDefinition.getComponents("ZOOKEEPER");
Assert.assertTrue(components.contains("ZOOKEEPER_SERVER"));
components=clusterDefinition.getComponents("HIVE");
Assert.assertTrue(components.contains("HIVE_SERVER"));
clusterDefinition=new ClusterDefinition(new TestStateProvider(),new TestClusterDefinitionProvider("clusterproperties_HDP2_HA.txt","myCluster","HDP-2.0.6"),new TestHostInfoProvider());
components=clusterDefinition.getComponents("HDFS");
Assert.assertTrue(components.contains("NAMENODE"));
Assert.assertTrue(components.contains("SECONDARY_NAMENODE"));
Assert.assertTrue(components.contains("DATANODE"));
Assert.assertTrue(components.contains("ZKFC"));
Assert.assertTrue(components.contains("JOURNALNODE"));
clusterDefinition=new ClusterDefinition(new TestStateProvider(),new TestClusterDefinitionProvider("clusterproperties_HDP21_HA.txt","myCluster","HDP-2.1.2"),new TestHostInfoProvider());
components=clusterDefinition.getComponents("HDFS");
Assert.assertTrue(components.contains("NAMENODE"));
Assert.assertTrue(components.contains("ZKFC"));
Assert.assertTrue(components.contains("JOURNALNODE"));
components=clusterDefinition.getComponents("YARN");
Assert.assertTrue(components.contains("RESOURCEMANAGER"));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier hostComponents=clusterDefinition.getHostComponents("HDFS","NAMENODE_MASTER.acme.com");
Assert.assertTrue(hostComponents.contains("NAMENODE"));
hostComponents=clusterDefinition.getHostComponents("HDFS","slave1.acme.com");
Assert.assertTrue(hostComponents.contains("DATANODE"));
hostComponents=clusterDefinition.getHostComponents("HDFS","slave2.acme.com");
Assert.assertTrue(hostComponents.contains("DATANODE"));
clusterDefinition=new ClusterDefinition(new TestStateProvider(),new TestClusterDefinitionProvider("clusterproperties_HDP2_HA.txt","myCluster","HDP-2.0.6"),new TestHostInfoProvider());
hostComponents=clusterDefinition.getHostComponents("HDFS","WINHDP-1");
Assert.assertTrue(hostComponents.contains("NAMENODE"));
Assert.assertTrue(hostComponents.contains("JOURNALNODE"));
Assert.assertTrue(hostComponents.contains("ZKFC"));
Assert.assertFalse(hostComponents.contains("DATANODE"));
Assert.assertFalse(hostComponents.contains("SECONDARY_NAMENODE"));
hostComponents=clusterDefinition.getHostComponents("HDFS","WINHDP-2");
Assert.assertTrue(hostComponents.contains("NAMENODE"));
Assert.assertTrue(hostComponents.contains("JOURNALNODE"));
Assert.assertTrue(hostComponents.contains("ZKFC"));
Assert.assertTrue(hostComponents.contains("DATANODE"));
Assert.assertTrue(hostComponents.contains("SECONDARY_NAMENODE"));
clusterDefinition=new ClusterDefinition(new TestStateProvider(),new TestClusterDefinitionProvider("clusterproperties_HDP21_HA.txt","myCluster","HDP-2.1.2"),new TestHostInfoProvider());
hostComponents=clusterDefinition.getHostComponents("YARN","WINHDP-1");
Assert.assertTrue(hostComponents.contains("RESOURCEMANAGER"));
hostComponents=clusterDefinition.getHostComponents("HDFS","WINHDP-1");
Assert.assertTrue(hostComponents.contains("NAMENODE"));
Assert.assertTrue(hostComponents.contains("JOURNALNODE"));
hostComponents=clusterDefinition.getHostComponents("YARN","WINHDP-2");
Assert.assertTrue(hostComponents.contains("RESOURCEMANAGER"));
hostComponents=clusterDefinition.getHostComponents("HDFS","WINHDP-2");
Assert.assertTrue(hostComponents.contains("NAMENODE"));
Assert.assertTrue(hostComponents.contains("JOURNALNODE"));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier services=clusterDefinition.getServices();
Assert.assertTrue(services.contains("HDFS"));
Assert.assertTrue(services.contains("FLUME"));
Assert.assertTrue(services.contains("OOZIE"));
Assert.assertTrue(services.contains("MAPREDUCE"));
Assert.assertTrue(services.contains("HBASE"));
Assert.assertTrue(services.contains("ZOOKEEPER"));
Assert.assertTrue(services.contains("HIVE"));
}
InternalCallVerifier EqualityVerifier Class: org.apache.ambari.msi.ClusterProviderTest InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
Assert.assertEquals("myCluster",resources.iterator().next().getPropertyValue(ClusterProvider.CLUSTER_NAME_PROPERTY_ID));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
Resource next=resources.iterator().next();
Assert.assertEquals("myCluster",next.getPropertyValue(ClusterProvider.CLUSTER_NAME_PROPERTY_ID));
Assert.assertEquals("HDP-1.2.9",next.getPropertyValue(ClusterProvider.CLUSTER_VERSION_PROPERTY_ID));
predicate=new PredicateBuilder().property(ClusterProvider.CLUSTER_NAME_PROPERTY_ID).equals("non-existent Cluster").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
Class: org.apache.ambari.msi.ComponentProviderTest InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(ComponentProvider.COMPONENT_STATE_PROPERTY_ID,"STARTED");
Request updateRequest=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(updateRequest,predicate);
Assert.assertEquals(StateProvider.State.Running,stateProvider.getState());
properties.put(ComponentProvider.COMPONENT_STATE_PROPERTY_ID,"INSTALLED");
updateRequest=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(updateRequest,predicate);
Assert.assertEquals(StateProvider.State.Stopped,stateProvider.getState());
properties.put(ComponentProvider.COMPONENT_STATE_PROPERTY_ID,"STARTED");
updateRequest=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(updateRequest,predicate);
Assert.assertEquals(StateProvider.State.Running,stateProvider.getState());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
predicate=new PredicateBuilder().property(ComponentProvider.COMPONENT_COMPONENT_NAME_PROPERTY_ID).equals("TASKTRACKER").or().property(ComponentProvider.COMPONENT_COMPONENT_NAME_PROPERTY_ID).equals("DATANODE").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(2,resources.size());
predicate=new PredicateBuilder().property(ComponentProvider.COMPONENT_COMPONENT_NAME_PROPERTY_ID).equals("BadComponent").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(15,resources.size());
}
Class: org.apache.ambari.msi.ConfigurationProviderTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("property_key","propery_value");
}
}
).times(5);
expect(clusterDefinitionMock.getClusterName()).andReturn("ambari");
PowerMock.replay(staxDriver,StaxDriver.class,xstream,XStream.class,ClassLoader.class);
replay(clusterDefinitionMock,mockInputStream);
ConfigurationProvider configurationProvider=new ConfigurationProvider(clusterDefinitionMock);
PowerMock.verify(staxDriver,StaxDriver.class,xstream,XStream.class,ClassLoader.class);
verify(clusterDefinitionMock,mockInputStream);
Predicate configPredicate=new PredicateBuilder().property(ConfigurationProvider.CONFIGURATION_CLUSTER_NAME_PROPERTY_ID).equals("ambari").and().property(ConfigurationProvider.CONFIGURATION_CONFIG_TYPE_PROPERTY_ID).equals("yarn-site").and().property(ConfigurationProvider.CONFIGURATION_CONFIG_TAG_PROPERTY_ID).equals("version1").toPredicate();
Set resources=configurationProvider.getResources(PropertyHelper.getReadRequest(),configPredicate);
Assert.assertNotNull(resources);
Assert.assertEquals(1,resources.size());
}
InternalCallVerifier EqualityVerifier (){
{
put("property_key","propery_value");
}
}
).times(5);
expect(clusterDefinitionMock.getClusterName()).andReturn("ambari");
PowerMock.replay(staxDriver,StaxDriver.class,xstream,XStream.class,ClassLoader.class);
replay(clusterDefinitionMock,mockInputStream);
ConfigurationProvider configurationProvider=new ConfigurationProvider(clusterDefinitionMock);
PowerMock.verify(staxDriver,StaxDriver.class,xstream,XStream.class,ClassLoader.class);
verify(clusterDefinitionMock,mockInputStream);
Assert.assertEquals(5,configurationProvider.getResources().size());
}
Class: org.apache.ambari.msi.HostComponentProviderTest InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(25,resources.size());
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(3,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("STARTED",resource.getPropertyValue(HostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID));
}
stateProvider.setHealthy(false);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(3,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("INSTALLED",resource.getPropertyValue(HostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID));
}
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(HostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID,"STARTED");
Request updateRequest=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(updateRequest,predicate);
Assert.assertEquals(StateProvider.State.Running,stateProvider.getState());
properties.put(HostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID,"INSTALLED");
updateRequest=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(updateRequest,predicate);
Assert.assertEquals(StateProvider.State.Stopped,stateProvider.getState());
properties.put(HostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID,"STARTED");
updateRequest=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(updateRequest,predicate);
Assert.assertEquals(StateProvider.State.Running,stateProvider.getState());
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest("HostRoles"),predicate);
Assert.assertEquals(3,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("STARTED",resource.getPropertyValue(HostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID));
}
stateProvider.setHealthy(false);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(3,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("INSTALLED",resource.getPropertyValue(HostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID));
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(5,resources.size());
predicate=new PredicateBuilder().property(HostComponentProvider.HOST_COMPONENT_HOST_NAME_PROPERTY_ID).equals("UnknownHost").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
Class: org.apache.ambari.msi.HostProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
String ip=(String)resource.getPropertyValue(HostProvider.HOST_IP_PROPERTY_ID);
Assert.assertEquals("127.0.0.1",ip);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
predicate=new PredicateBuilder().property(HostProvider.HOST_NAME_PROPERTY_ID).equals("HBASE_MASTER.acme.com").or().property(HostProvider.HOST_NAME_PROPERTY_ID).equals("slave3.acme.com").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(2,resources.size());
predicate=new PredicateBuilder().property(HostProvider.HOST_NAME_PROPERTY_ID).equals("unknownHost").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest("Hosts"),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("HEALTHY",resource.getPropertyValue(HostProvider.HOST_STATE_PROPERTY_ID));
stateProvider.setState(StateProvider.State.Unknown);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
resource=resources.iterator().next();
Assert.assertEquals("UNHEALTHY",resource.getPropertyValue(HostProvider.HOST_STATE_PROPERTY_ID));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("HEALTHY",resource.getPropertyValue(HostProvider.HOST_STATE_PROPERTY_ID));
stateProvider.setState(StateProvider.State.Unknown);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
resource=resources.iterator().next();
Assert.assertEquals("UNHEALTHY",resource.getPropertyValue(HostProvider.HOST_STATE_PROPERTY_ID));
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(13,resources.size());
}
Class: org.apache.ambari.msi.RequestProviderTest InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
}
Class: org.apache.ambari.msi.ServiceProviderTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
predicate=new PredicateBuilder().property(ServiceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("HDFS").or().property(ServiceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("FLUME").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(2,resources.size());
predicate=new PredicateBuilder().property(ServiceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("NO SERVICE").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("STARTED",resource.getPropertyValue(ServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
stateProvider.setHealthy(false);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
resource=resources.iterator().next();
Assert.assertEquals("INSTALLED",resource.getPropertyValue(ServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(ServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID,"STARTED");
Request updateRequest=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(updateRequest,predicate);
Assert.assertEquals(StateProvider.State.Running,stateProvider.getState());
properties.put(ServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID,"INSTALLED");
updateRequest=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(updateRequest,predicate);
Assert.assertEquals(StateProvider.State.Stopped,stateProvider.getState());
properties.put(ServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID,"STARTED");
updateRequest=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(updateRequest,predicate);
Assert.assertEquals(StateProvider.State.Running,stateProvider.getState());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest("ServiceInfo"),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("STARTED",resource.getPropertyValue(ServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
stateProvider.setHealthy(false);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
resource=resources.iterator().next();
Assert.assertEquals("INSTALLED",resource.getPropertyValue(ServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(7,resources.size());
}
Class: org.apache.ambari.msi.TaskProviderTest InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
}
Class: org.apache.ambari.scom.ClusterDefinitionProviderTest InternalCallVerifier NullVerifier Class: org.apache.ambari.scom.SQLPropertyProviderTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier temporalInfoMap=new HashMap();
temporalInfoMap.put(PROPERTY_ID_1,new TemporalInfoImpl(10L,-1L,-1L));
Request request=PropertyHelper.getReadRequest(Collections.singleton(PROPERTY_ID_1),temporalInfoMap);
provider.populateResources(Collections.singleton(resource),request,null);
Assert.assertNull(hostProvider.getHostId());
Assert.assertEquals("c1",hostProvider.getClusterName());
Assert.assertEquals("DATANODE",hostProvider.getComponentName());
verify(connectionFactory,connection,statement,resultSet);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier temporalInfoMap=new HashMap();
temporalInfoMap.put(PROPERTY_ID_1,new TemporalInfoImpl(10L,-1L,-1L));
Request request=PropertyHelper.getReadRequest(Collections.singleton(PROPERTY_ID_1),temporalInfoMap);
provider.populateResources(Collections.singleton(resource),request,null);
Assert.assertEquals("domU-12-31-39-0E-34-E1.compute-1.internal",hostProvider.getHostId());
Assert.assertNull(hostProvider.getClusterName());
Assert.assertNull(hostProvider.getComponentName());
verify(connectionFactory,connection,statement,resultSet);
}
APIUtilityVerifier IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier temporalInfoMap=new HashMap();
temporalInfoMap.put(PROPERTY_ID_1,new TemporalInfoImpl(10L,20L,1L));
Set propertyIds=new LinkedHashSet();
propertyIds.add(PROPERTY_ID_1);
propertyIds.add(PROPERTY_ID_2);
Request request=PropertyHelper.getReadRequest(propertyIds,temporalInfoMap);
Assert.assertEquals(1,provider.populateResources(Collections.singleton(resource),request,null).size());
Assert.assertTrue(resource.getPropertyValue(PROPERTY_ID_1) instanceof Number[][]);
Number[][] datapoints=(Number[][])resource.getPropertyValue(PROPERTY_ID_1);
for (int i=0; i < datapoints.length; ++i) {
Assert.assertEquals((long)i,datapoints[i][0]);
Assert.assertEquals((999990L + i) / 1000,datapoints[i][1]);
}
Assert.assertEquals(3L,resource.getPropertyValue(PROPERTY_ID_2));
verify(connectionFactory,connection,statement,resultSet);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier temporalInfoMap=new HashMap();
Request request=PropertyHelper.getReadRequest(Collections.singleton(PROPERTY_ID_2),temporalInfoMap);
Assert.assertEquals(1,provider.populateResources(Collections.singleton(resource),request,null).size());
Assert.assertEquals(3L,resource.getPropertyValue(PROPERTY_ID_2));
verify(connectionFactory,connection,statement,resultSet);
}
APIUtilityVerifier IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier temporalInfoMap=new HashMap();
temporalInfoMap.put(PROPERTY_ID_1,new TemporalInfoImpl(10L,20L,1L));
Request request=PropertyHelper.getReadRequest(Collections.singleton(PROPERTY_ID_1),temporalInfoMap);
Assert.assertEquals(1,provider.populateResources(Collections.singleton(resource),request,null).size());
Assert.assertTrue(resource.getPropertyValue(PROPERTY_ID_1) instanceof Number[][]);
Number[][] datapoints=(Number[][])resource.getPropertyValue(PROPERTY_ID_1);
for (int i=0; i < datapoints.length; ++i) {
Assert.assertEquals((long)i,datapoints[i][0]);
Assert.assertEquals((999990L + i) / 1000,datapoints[i][1]);
}
verify(connectionFactory,connection,statement,resultSet);
}
APIUtilityVerifier IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier temporalInfoMap=new HashMap();
temporalInfoMap.put(PROPERTY_ID_1,new TemporalInfoImpl(10L,-1L,-1L));
Request request=PropertyHelper.getReadRequest(Collections.singleton(PROPERTY_ID_1),temporalInfoMap);
Assert.assertEquals(1,provider.populateResources(Collections.singleton(resource),request,null).size());
Assert.assertTrue(resource.getPropertyValue(PROPERTY_ID_1) instanceof Number[][]);
Number[][] datapoints=(Number[][])resource.getPropertyValue(PROPERTY_ID_1);
for (int i=0; i < datapoints.length; ++i) {
Assert.assertEquals((long)i,datapoints[i][0]);
Assert.assertEquals((999990L + i) / 1000,datapoints[i][1]);
}
verify(connectionFactory,connection,statement,resultSet);
}
Class: org.apache.ambari.scom.SQLProviderModuleTest InternalCallVerifier BooleanVerifier providers=providerModule.getPropertyProviders(Resource.Type.Component);
Assert.assertTrue(providers.get(0) instanceof JMXPropertyProvider);
Assert.assertTrue(providers.get(1) instanceof SQLPropertyProvider);
providerModule.createPropertyProviders(Resource.Type.HostComponent);
providers=providerModule.getPropertyProviders(Resource.Type.HostComponent);
Assert.assertTrue(providers.get(0) instanceof JMXPropertyProvider);
Assert.assertTrue(providers.get(1) instanceof SQLPropertyProvider);
}
Class: org.apache.ambari.scom.logging.JpaLoggerTest InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.actionmanager.ExecutionCommandWrapperTest InternalCallVerifier EqualityVerifier baseConfig=new HashMap();
baseConfig.put(SERVICE_SITE_NAME1,SERVICE_SITE_VAL1);
baseConfig.put(SERVICE_SITE_NAME2,SERVICE_SITE_VAL2);
baseConfig.put(SERVICE_SITE_NAME3,SERVICE_SITE_VAL3);
baseConfig.put(SERVICE_SITE_NAME4,SERVICE_SITE_VAL4);
baseConfig.put(SERVICE_SITE_NAME5,SERVICE_SITE_VAL5);
Map overrideConfig=new HashMap();
overrideConfig.put(SERVICE_SITE_NAME2,SERVICE_SITE_VAL2_H);
overrideConfig.put(SERVICE_SITE_NAME6,SERVICE_SITE_VAL6_H);
Map mergedConfig=configHelper.getMergedConfig(baseConfig,overrideConfig);
Set configsKeys=new HashSet();
configsKeys.addAll(baseConfig.keySet());
configsKeys.addAll(overrideConfig.keySet());
Assert.assertEquals(configsKeys.size(),mergedConfig.size());
Assert.assertEquals(SERVICE_SITE_VAL1,mergedConfig.get(SERVICE_SITE_NAME1));
Assert.assertEquals(SERVICE_SITE_VAL2_H,mergedConfig.get(SERVICE_SITE_NAME2));
Assert.assertEquals(SERVICE_SITE_VAL3,mergedConfig.get(SERVICE_SITE_NAME3));
Assert.assertEquals(SERVICE_SITE_VAL4,mergedConfig.get(SERVICE_SITE_NAME4));
Assert.assertEquals(SERVICE_SITE_VAL5,mergedConfig.get(SERVICE_SITE_NAME5));
Assert.assertEquals(SERVICE_SITE_VAL6_H,mergedConfig.get(SERVICE_SITE_NAME6));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > confs=new HashMap>();
Map configurationsGlobal=new HashMap();
configurationsGlobal.put(GLOBAL_NAME1,GLOBAL_VAL1);
confs.put(GLOBAL_CONFIG,configurationsGlobal);
Map> confTags=new HashMap>();
Map confTagServiceSite=new HashMap();
confTagServiceSite.put("tag",CLUSTER_VERSION_TAG);
confTagServiceSite.put("service_override_tag",SERVICE_VERSION_TAG);
confTagServiceSite.put("host_override_tag",HOST_VERSION_TAG);
confTags.put(SERVICE_SITE_CONFIG,confTagServiceSite);
Map confTagGlobal=Collections.singletonMap("tag",CLUSTER_VERSION_TAG);
confTags.put(GLOBAL_CONFIG,confTagGlobal);
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setClusterName(CLUSTER1);
executionCommand.setTaskId(1);
executionCommand.setRequestAndStage(1,1);
executionCommand.setHostname(HOST1);
executionCommand.setRole("NAMENODE");
executionCommand.setRoleParams(Collections.emptyMap());
executionCommand.setRoleCommand(RoleCommand.START);
executionCommand.setConfigurations(confs);
executionCommand.setConfigurationTags(confTags);
executionCommand.setServiceName("HDFS");
executionCommand.setCommandType(AgentCommandType.EXECUTION_COMMAND);
executionCommand.setCommandParams(Collections.emptyMap());
String json=StageUtils.getGson().toJson(executionCommand,ExecutionCommand.class);
ExecutionCommandWrapper execCommWrap=new ExecutionCommandWrapper(json);
ExecutionCommand processedExecutionCommand=execCommWrap.getExecutionCommand();
Map serviceSiteConfig=processedExecutionCommand.getConfigurations().get(SERVICE_SITE_CONFIG);
Assert.assertEquals(SERVICE_SITE_VAL1_S,serviceSiteConfig.get(SERVICE_SITE_NAME1));
Assert.assertEquals(SERVICE_SITE_VAL2_H,serviceSiteConfig.get(SERVICE_SITE_NAME2));
Assert.assertEquals(SERVICE_SITE_VAL3,serviceSiteConfig.get(SERVICE_SITE_NAME3));
Assert.assertEquals(SERVICE_SITE_VAL4,serviceSiteConfig.get(SERVICE_SITE_NAME4));
Assert.assertEquals(SERVICE_SITE_VAL5_S,serviceSiteConfig.get(SERVICE_SITE_NAME5));
Assert.assertEquals(SERVICE_SITE_VAL6_H,serviceSiteConfig.get(SERVICE_SITE_NAME6));
Map globalConfig=processedExecutionCommand.getConfigurations().get(GLOBAL_CONFIG);
Assert.assertEquals(GLOBAL_VAL1,globalConfig.get(GLOBAL_NAME1));
Assert.assertEquals(GLOBAL_CLUSTER_VAL2,globalConfig.get(GLOBAL_NAME2));
Set serviceSiteKeys=new HashSet();
serviceSiteKeys.addAll(SERVICE_SITE_CLUSTER.keySet());
serviceSiteKeys.addAll(SERVICE_SITE_SERVICE.keySet());
serviceSiteKeys.addAll(SERVICE_SITE_HOST.keySet());
Assert.assertEquals(serviceSiteKeys.size(),serviceSiteConfig.size());
}
Class: org.apache.ambari.server.actionmanager.StageTest APIUtilityVerifier InternalCallVerifier EqualityVerifier emptyMap(),null,null,1200,false,false);
List executionCommands=stage.getExecutionCommands(null);
assertEquals(1,executionCommands.size());
String actionUserName=executionCommands.get(0).getExecutionCommand().getRoleParams().get(ServerAction.ACTION_USER_NAME);
assertEquals("user1",actionUserName);
}
Class: org.apache.ambari.server.actionmanager.TestActionDBAccessorImpl InternalCallVerifier EqualityVerifier stages=db.getStagesInProgress();
assertEquals(2,stages.size());
db.abortOperation(requestId);
stages=db.getStagesInProgress();
assertEquals(1,stages.size());
assertEquals(requestId + 1,stages.get(0).getRequestId());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier entities=hostRoleCommandDAO.findByHostRole(hostName,requestId,stageId,Role.HBASE_MASTER.toString());
assertEquals(HostRoleStatus.PENDING,entities.get(0).getStatus());
stage.setHostRoleStatus(hostName,Role.HBASE_MASTER.toString(),HostRoleStatus.QUEUED);
entities=hostRoleCommandDAO.findByHostRole(hostName,requestId,stageId,Role.HBASE_MASTER.toString());
assertEquals(HostRoleStatus.QUEUED,stage.getHostRoleStatus(hostName,Role.HBASE_MASTER.toString()));
assertEquals(HostRoleStatus.PENDING,entities.get(0).getStatus());
db.hostRoleScheduled(stage,hostName,Role.HBASE_MASTER.toString());
entities=hostRoleCommandDAO.findByHostRole(hostName,requestId,stageId,Role.HBASE_MASTER.toString());
assertEquals(HostRoleStatus.QUEUED,entities.get(0).getStatus());
Thread thread=new Thread(){
@Override public void run(){
Stage stage1=db.getStage("23-31");
stage1.setHostRoleStatus(hostName,Role.HBASE_MASTER.toString(),HostRoleStatus.COMPLETED);
db.hostRoleScheduled(stage1,hostName,Role.HBASE_MASTER.toString());
injector.getInstance(EntityManager.class).clear();
}
}
;
thread.start();
thread.join();
injector.getInstance(EntityManager.class).clear();
entities=hostRoleCommandDAO.findByHostRole(hostName,requestId,stageId,Role.HBASE_MASTER.toString());
assertEquals("Concurrent update failed",HostRoleStatus.COMPLETED,entities.get(0).getStatus());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier entities=hostRoleCommandDAO.findByHostRole(null,requestId,stageId,roleName);
assertEquals(HostRoleStatus.PENDING,entities.get(0).getStatus());
stage.setHostRoleStatus(null,roleName,HostRoleStatus.QUEUED);
entities=hostRoleCommandDAO.findByHostRole(null,requestId,stageId,roleName);
assertEquals(HostRoleStatus.QUEUED,stage.getHostRoleStatus(null,roleName));
assertEquals(HostRoleStatus.PENDING,entities.get(0).getStatus());
db.hostRoleScheduled(stage,null,roleName);
entities=hostRoleCommandDAO.findByHostRole(null,requestId,stageId,roleName);
assertEquals(HostRoleStatus.QUEUED,entities.get(0).getStatus());
Thread thread=new Thread(){
@Override public void run(){
Stage stage1=db.getStage("23-31");
stage1.setHostRoleStatus(null,roleName,HostRoleStatus.COMPLETED);
db.hostRoleScheduled(stage1,null,roleName);
injector.getInstance(EntityManager.class).clear();
}
}
;
thread.start();
thread.join();
injector.getInstance(EntityManager.class).clear();
entities=hostRoleCommandDAO.findByHostRole(null,requestId,stageId,roleName);
assertEquals("Concurrent update failed",HostRoleStatus.COMPLETED,entities.get(0).getStatus());
}
InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier entities=hostRoleCommandDAO.findByHostRole(hostName,requestId,stageId,actionName);
assertEquals(HostRoleStatus.PENDING,entities.get(0).getStatus());
stage.setHostRoleStatus(hostName,actionName,HostRoleStatus.QUEUED);
entities=hostRoleCommandDAO.findByHostRole(hostName,requestId,stageId,actionName);
assertEquals(HostRoleStatus.QUEUED,stage.getHostRoleStatus(hostName,actionName));
assertEquals(HostRoleStatus.PENDING,entities.get(0).getStatus());
db.hostRoleScheduled(stage,hostName,actionName);
entities=hostRoleCommandDAO.findByHostRole(hostName,requestId,stageId,actionName);
assertEquals(HostRoleStatus.QUEUED,entities.get(0).getStatus());
Thread thread=new Thread(){
@Override public void run(){
Stage stage1=db.getStage("23-31");
stage1.setHostRoleStatus(hostName,actionName,HostRoleStatus.COMPLETED);
db.hostRoleScheduled(stage1,hostName,actionName);
injector.getInstance(EntityManager.class).clear();
}
}
;
thread.start();
thread.join();
injector.getInstance(EntityManager.class).clear();
entities=hostRoleCommandDAO.findByHostRole(hostName,requestId,stageId,actionName);
assertEquals("Concurrent update failed",HostRoleStatus.COMPLETED,entities.get(0).getStatus());
}
InternalCallVerifier EqualityVerifier stages=new ArrayList();
stages.add(s);
Request request=new Request(stages,clusters);
db.persistActions(request);
List entities=hostRoleCommandDAO.findByRequest(request.getRequestId());
assertEquals(1002,entities.size());
List taskIds=new ArrayList();
for ( HostRoleCommandEntity entity : entities) {
taskIds.add(entity.getTaskId());
}
TestDBAccessorImpl testDBAccessorImpl=(TestDBAccessorImpl)injector.getInstance(DBAccessor.class);
testDBAccessorImpl.setDbTypeOverride(ORACLE);
assertEquals(ORACLE,injector.getInstance(DBAccessor.class).getDbType());
entities=hostRoleCommandDAO.findByPKs(taskIds);
assertEquals("Tasks returned from DB match the ones created",taskIds.size(),entities.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier requestIds=new ArrayList();
requestIds.add(requestId + 1);
requestIds.add(requestId);
populateActionDB(db,hostName,requestId,stageId);
clusters.addHost("host2");
clusters.getHost("host2").persist();
populateActionDB(db,hostName,requestId + 1,stageId);
List requestIdsResult=db.getRequestsByStatus(null,BaseRequest.DEFAULT_PAGE_SIZE,false);
assertNotNull("List of request IDs is null",requestIdsResult);
assertEquals("Request IDs not matches",requestIds,requestIdsResult);
}
BranchVerifier InternalCallVerifier EqualityVerifier stages=new ArrayList();
stages.add(s);
s.getOrderedHostRoleCommands().get(0).setStatus(HostRoleStatus.PENDING);
s.getOrderedHostRoleCommands().get(1).setStatus(HostRoleStatus.IN_PROGRESS);
s.getOrderedHostRoleCommands().get(2).setStatus(HostRoleStatus.QUEUED);
HostRoleCommand cmd=s.getOrderedHostRoleCommands().get(3);
String hostName=cmd.getHostName();
cmd.setStatus(HostRoleStatus.COMPLETED);
Request request=new Request(stages,clusters);
db.persistActions(request);
db.abortOperation(requestId);
List aborted=new ArrayList();
List commands=db.getRequestTasks(requestId);
for ( HostRoleCommand command : commands) {
if (command.getHostName().equals(hostName)) {
assertEquals(HostRoleStatus.COMPLETED,command.getStatus());
}
else {
assertEquals(HostRoleStatus.ABORTED,command.getStatus());
aborted.add(command.getTaskId());
}
}
db.resubmitTasks(aborted);
commands=db.getRequestTasks(requestId);
for ( HostRoleCommand command : commands) {
if (command.getHostName().equals(hostName)) {
assertEquals(HostRoleStatus.COMPLETED,command.getStatus());
}
else {
assertEquals(HostRoleStatus.PENDING,command.getStatus());
}
}
}
InternalCallVerifier EqualityVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setTaskId(1);
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setRole("HBASE_MASTER");
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(0);
reports.add(cr);
am.processTaskResponse(hostname,reports,stage.getOrderedHostRoleCommands());
assertEquals(0,am.getAction(requestId,stageId).getExitCode(hostname,"HBASE_MASTER"));
assertEquals("HostRoleStatus should remain ABORTED " + "(command report status should be ignored)",HostRoleStatus.ABORTED,am.getAction(requestId,stageId).getHostRoleStatus(hostname,"HBASE_MASTER"));
Stage s=db.getAllStages(requestId).get(0);
assertEquals("HostRoleStatus should remain ABORTED " + "(command report status should be ignored)",HostRoleStatus.ABORTED,s.getHostRoleStatus(hostname,"HBASE_MASTER"));
}
InternalCallVerifier EqualityVerifier stages=db.getStagesInProgress();
assertEquals(6000,commandsInProgressCount);
assertEquals(3000,stages.size());
}
InternalCallVerifier EqualityVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setTaskId(1);
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setRole("HBASE_MASTER");
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
reports.add(cr);
am.processTaskResponse(hostname,reports,stage.getOrderedHostRoleCommands());
assertEquals(215,am.getAction(requestId,stageId).getExitCode(hostname,"HBASE_MASTER"));
assertEquals(HostRoleStatus.COMPLETED,am.getAction(requestId,stageId).getHostRoleStatus(hostname,"HBASE_MASTER"));
Stage s=db.getAllStages(requestId).get(0);
assertEquals(HostRoleStatus.COMPLETED,s.getHostRoleStatus(hostname,"HBASE_MASTER"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier requestIds=new ArrayList();
requestIds.add(requestId);
requestIds.add(requestId + 1);
populateActionDBWithCompletedRequest(db,hostName,requestId,stageId);
List requestIdsResult=db.getRequestsByStatus(RequestStatus.COMPLETED,BaseRequest.DEFAULT_PAGE_SIZE,false);
assertEquals(1,requestIdsResult.size());
assertTrue(requestIdsResult.contains(requestId));
populateActionDBWithPartiallyCompletedRequest(db,hostName,requestId + 1,stageId);
requestIdsResult=db.getRequestsByStatus(RequestStatus.COMPLETED,BaseRequest.DEFAULT_PAGE_SIZE,false);
assertEquals(1,requestIdsResult.size());
assertTrue(requestIdsResult.contains(requestId));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier stages=db.getStagesInProgress();
assertEquals(18,commandsInProgressCount);
assertEquals(9,stages.size());
long lastRequestId=Integer.MIN_VALUE;
for ( Stage stage : stages) {
assertTrue(stage.getRequestId() >= lastRequestId);
lastRequestId=stage.getRequestId();
}
db.abortOperation(requestId);
commandsInProgressCount=db.getCommandsInProgressCount();
stages=db.getStagesInProgress();
assertEquals(12,commandsInProgressCount);
assertEquals(6,stages.size());
stages.get(0).setHostRoleStatus(hostName,Role.HBASE_MASTER.toString(),HostRoleStatus.COMPLETED);
db.hostRoleScheduled(stages.get(0),hostName,Role.HBASE_MASTER.toString());
commandsInProgressCount=db.getCommandsInProgressCount();
stages=db.getStagesInProgress();
assertEquals(11,commandsInProgressCount);
assertEquals(6,stages.size());
stages.get(0).setHostRoleStatus(hostName,Role.HBASE_REGIONSERVER.toString(),HostRoleStatus.COMPLETED);
db.hostRoleScheduled(stages.get(0),hostName,Role.HBASE_REGIONSERVER.toString());
commandsInProgressCount=db.getCommandsInProgressCount();
stages=db.getStagesInProgress();
assertEquals(10,commandsInProgressCount);
assertEquals(5,stages.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier ids=new ArrayList();
for (long l=1; l <= 10; l++) {
ids.add(l);
}
for ( Long id : ids) {
populateActionDB(db,hostName,id,stageId);
}
List expected=null;
List actual=null;
actual=db.getRequestsByStatus(null,BaseRequest.DEFAULT_PAGE_SIZE,false);
expected=reverse(new ArrayList(ids));
assertEquals("Request IDs not matches",expected,actual);
actual=db.getRequestsByStatus(null,4,false);
expected=reverse(new ArrayList(ids.subList(ids.size() - 4,ids.size())));
assertEquals("Request IDs not matches",expected,actual);
actual=db.getRequestsByStatus(null,7,true);
expected=new ArrayList(ids.subList(0,7));
assertEquals("Request IDs not matches",expected,actual);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier commandEntities=hostRoleCommandDAO.findByHostRole(hostName,requestId,stageId,Role.HBASE_MASTER.toString());
assertEquals(1,commandEntities.size());
HostRoleCommandEntity commandEntity=commandEntities.get(0);
HostRoleCommand command=db.getTask(commandEntity.getTaskId());
assertNotNull(command);
assertEquals(largeString,command.getStdout());
assertEquals(largeString,command.getStructuredOut());
assertTrue(command.getEndTime() != -1);
}
Class: org.apache.ambari.server.actionmanager.TestActionManager InternalCallVerifier EqualityVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setTaskId(1);
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setRole("HBASE_MASTER");
cr.setStatus("COMPLETED");
String errLog=Arrays.toString(new byte[100000]);
String outLog=Arrays.toString(new byte[110000]);
cr.setStdErr(errLog);
cr.setStdOut(outLog);
cr.setStructuredOut(outLog);
cr.setExitCode(215);
reports.add(cr);
am.processTaskResponse(hostname,reports,stage.getOrderedHostRoleCommands());
assertEquals(215,am.getAction(requestId,stageId).getExitCode(hostname,"HBASE_MASTER"));
assertEquals(HostRoleStatus.COMPLETED,am.getAction(requestId,stageId).getHostRoleStatus(hostname,"HBASE_MASTER"));
assertEquals(errLog.length(),am.getAction(requestId,stageId).getHostRoleCommand(hostname,"HBASE_MASTER").getStderr().length());
assertEquals(outLog.length(),am.getAction(requestId,stageId).getHostRoleCommand(hostname,"HBASE_MASTER").getStdout().length());
assertEquals(outLog.length(),am.getAction(requestId,stageId).getHostRoleCommand(hostname,"HBASE_MASTER").getStructuredOut().length());
}
InternalCallVerifier EqualityVerifier IgnoredMethod HybridVerifier InternalCallVerifier IdentityVerifier listStages=new ArrayList();
listStages.add(stage1);
listStages.add(stage2);
expect(db.getLastPersistedRequestIdWhenInitialized()).andReturn(Long.valueOf(1000));
expect(db.getAllStages(requestId)).andReturn(listStages);
replay(queue,db,clusters);
ActionManager manager=new ActionManager(0,0,queue,clusters,db,null,unitOfWork,injector.getInstance(RequestFactory.class),null,null);
assertSame(listStages,manager.getActions(requestId));
verify(queue,db,clusters);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setTaskId(1);
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setRole("HBASE_MASTER");
cr.setStatus("COMPLETED");
cr.setStdErr("ERROR");
cr.setStdOut("OUTPUT");
cr.setStructuredOut("STRUCTURED_OUTPUT");
cr.setExitCode(215);
reports.add(cr);
am.processTaskResponse(hostname,reports,stage.getOrderedHostRoleCommands());
assertEquals(215,am.getAction(requestId,stageId).getExitCode(hostname,"HBASE_MASTER"));
assertEquals(HostRoleStatus.COMPLETED,am.getAction(requestId,stageId).getHostRoleStatus(hostname,"HBASE_MASTER"));
assertEquals("ERROR",am.getAction(requestId,stageId).getHostRoleCommand(hostname,"HBASE_MASTER").getStderr());
assertEquals("OUTPUT",am.getAction(requestId,stageId).getHostRoleCommand(hostname,"HBASE_MASTER").getStdout());
assertEquals("STRUCTURED_OUTPUT",am.getAction(requestId,stageId).getHostRoleCommand(hostname,"HBASE_MASTER").getStructuredOut());
assertNotNull(db.getRequest(requestId));
assertFalse(db.getRequest(requestId).getEndTime() == -1);
}
Class: org.apache.ambari.server.actionmanager.TestActionScheduler APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier >>(){
}
.getType();
Map> clusterHostInfo1=StageUtils.getGson().fromJson(CLUSTER_HOST_INFO,type);
Map> clusterHostInfo2=StageUtils.getGson().fromJson(CLUSTER_HOST_INFO_UPDATED,type);
int stageId=1;
int requestId1=1;
int requestId2=2;
ActionQueue aq=new ActionQueue();
Properties properties=new Properties();
Configuration conf=new Configuration(properties);
Clusters fsm=mock(Clusters.class);
Cluster oneClusterMock=mock(Cluster.class);
Service serviceObj=mock(Service.class);
ServiceComponent scomp=mock(ServiceComponent.class);
ServiceComponentHost sch=mock(ServiceComponentHost.class);
UnitOfWork unitOfWork=mock(UnitOfWork.class);
when(fsm.getCluster(anyString())).thenReturn(oneClusterMock);
when(oneClusterMock.getService(anyString())).thenReturn(serviceObj);
when(serviceObj.getServiceComponent(anyString())).thenReturn(scomp);
when(scomp.getServiceComponentHost(anyString())).thenReturn(sch);
when(serviceObj.getCluster()).thenReturn(oneClusterMock);
Host host=mock(Host.class);
HashMap hosts=new HashMap();
hosts.put(hostname,sch);
when(scomp.getServiceComponentHosts()).thenReturn(hosts);
when(fsm.getHost(anyString())).thenReturn(host);
when(host.getState()).thenReturn(HostState.HEALTHY);
when(host.getHostName()).thenReturn(hostname);
ActionDBAccessor db=mock(ActionDBAccessorImpl.class);
RequestEntity request=mock(RequestEntity.class);
when(request.isExclusive()).thenReturn(false);
when(db.getRequestEntity(anyLong())).thenReturn(request);
Stage s1=StageUtils.getATestStage(requestId1,stageId,hostname,CLUSTER_HOST_INFO,"{\"host_param\":\"param_value\"}","{\"stage_param\":\"param_value\"}");
Stage s2=StageUtils.getATestStage(requestId2,stageId,hostname,CLUSTER_HOST_INFO_UPDATED,"{\"host_param\":\"param_value\"}","{\"stage_param\":\"param_value\"}");
when(db.getCommandsInProgressCount()).thenReturn(1);
when(db.getStagesInProgress()).thenReturn(Collections.singletonList(s1));
ActionScheduler scheduler=new ActionScheduler(100,100,db,aq,fsm,10000,new HostsMap((String)null),unitOfWork,null,conf);
scheduler.setTaskTimeoutAdjustment(false);
List ac=waitForQueueSize(hostname,aq,1,scheduler);
assertTrue(ac.get(0) instanceof ExecutionCommand);
assertEquals(String.valueOf(requestId1) + "-" + stageId,((ExecutionCommand)(ac.get(0))).getCommandId());
assertEquals(clusterHostInfo1,((ExecutionCommand)(ac.get(0))).getClusterHostInfo());
when(db.getCommandsInProgressCount()).thenReturn(1);
when(db.getStagesInProgress()).thenReturn(Collections.singletonList(s2));
ac=waitForQueueSize(hostname,aq,1,scheduler);
assertTrue(ac.get(0) instanceof ExecutionCommand);
assertEquals(String.valueOf(requestId2) + "-" + stageId,((ExecutionCommand)(ac.get(0))).getCommandId());
assertEquals(clusterHostInfo2,((ExecutionCommand)(ac.get(0))).getClusterHostInfo());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hosts=new HashMap();
hosts.put(hostname1,sch1);
hosts.put(hostname2,sch2);
when(scomp.getServiceComponentHosts()).thenReturn(hosts);
when(fsm.getHost(hostname1)).thenReturn(host1);
when(fsm.getHost(hostname2)).thenReturn(host2);
when(host1.getState()).thenReturn(HostState.HEARTBEAT_LOST);
when(host2.getState()).thenReturn(HostState.HEALTHY);
when(host1.getHostName()).thenReturn(hostname1);
when(host2.getHostName()).thenReturn(hostname2);
when(scomp.getServiceComponentHost(hostname1)).thenReturn(sch1);
when(scomp.getServiceComponentHost(hostname2)).thenReturn(sch2);
UnitOfWork unitOfWork=mock(UnitOfWork.class);
when(fsm.getCluster(anyString())).thenReturn(oneClusterMock);
when(oneClusterMock.getService(anyString())).thenReturn(serviceObj);
when(serviceObj.getServiceComponent(anyString())).thenReturn(scomp);
when(serviceObj.getCluster()).thenReturn(oneClusterMock);
final List stages=new ArrayList();
Stage stage=stageFactory.createNew(1,"/tmp","cluster1",1L,"stageWith2Tasks",CLUSTER_HOST_INFO,"{\"command_param\":\"param_value\"}","{\"host_param\":\"param_value\"}");
addInstallTaskToStage(stage,hostname1,"cluster1",Role.DATANODE,RoleCommand.INSTALL,Service.Type.HDFS,1);
addInstallTaskToStage(stage,hostname2,"cluster1",Role.NAMENODE,RoleCommand.INSTALL,Service.Type.HDFS,2);
stages.add(stage);
ActionDBAccessor db=mock(ActionDBAccessor.class);
RequestEntity request=mock(RequestEntity.class);
when(request.isExclusive()).thenReturn(false);
when(db.getRequestEntity(anyLong())).thenReturn(request);
when(db.getCommandsInProgressCount()).thenReturn(stages.size());
when(db.getStagesInProgress()).thenReturn(stages);
doAnswer(new Answer(){
@Override public Void answer( InvocationOnMock invocation) throws Throwable {
String host=(String)invocation.getArguments()[0];
String role=(String)invocation.getArguments()[3];
for ( HostRoleCommand command : stages.get(0).getOrderedHostRoleCommands()) {
if (command.getHostName().equals(host) && command.getRole().name().equals(role)) {
command.setStatus(HostRoleStatus.TIMEDOUT);
}
}
return null;
}
}
).when(db).timeoutHostRole(anyString(),anyLong(),anyLong(),anyString());
doAnswer(new Answer(){
@Override public Void answer( InvocationOnMock invocation) throws Throwable {
Long requestId=(Long)invocation.getArguments()[0];
for ( Stage stage : stages) {
if (requestId.equals(stage.getRequestId())) {
for ( HostRoleCommand command : stage.getOrderedHostRoleCommands()) {
if (command.getStatus() == HostRoleStatus.QUEUED || command.getStatus() == HostRoleStatus.IN_PROGRESS || command.getStatus() == HostRoleStatus.PENDING) {
command.setStatus(HostRoleStatus.ABORTED);
}
}
}
}
return null;
}
}
).when(db).abortOperation(anyLong());
ArgumentCaptor eventsCapture1=ArgumentCaptor.forClass(ServiceComponentHostEvent.class);
ArgumentCaptor eventsCapture2=ArgumentCaptor.forClass(ServiceComponentHostEvent.class);
ActionScheduler scheduler=new ActionScheduler(100,50000,db,aq,fsm,3,new HostsMap((String)null),unitOfWork,null,conf);
scheduler.setTaskTimeoutAdjustment(false);
int cycleCount=0;
while (!(stages.get(0).getHostRoleStatus(hostname1,"DATANODE").equals(HostRoleStatus.TIMEDOUT) && stages.get(0).getHostRoleStatus(hostname2,"NAMENODE").equals(HostRoleStatus.ABORTED)) && cycleCount++ <= MAX_CYCLE_ITERATIONS) {
scheduler.doWork();
}
Assert.assertEquals(HostRoleStatus.TIMEDOUT,stages.get(0).getHostRoleStatus(hostname1,"DATANODE"));
Assert.assertEquals(HostRoleStatus.ABORTED,stages.get(0).getHostRoleStatus(hostname2,"NAMENODE"));
verify(sch1,atLeastOnce()).handleEvent(eventsCapture1.capture());
verify(sch2,atLeastOnce()).handleEvent(eventsCapture2.capture());
List eventTypes=eventsCapture1.getAllValues();
eventTypes.addAll(eventsCapture2.getAllValues());
Assert.assertNotNull(eventTypes);
ServiceComponentHostOpFailedEvent datanodeFailedEvent=null;
ServiceComponentHostOpFailedEvent namenodeFailedEvent=null;
for ( ServiceComponentHostEvent eventType : eventTypes) {
if (eventType instanceof ServiceComponentHostOpFailedEvent) {
ServiceComponentHostOpFailedEvent event=(ServiceComponentHostOpFailedEvent)eventType;
if (event.getServiceComponentName().equals("DATANODE")) {
datanodeFailedEvent=event;
}
else if (event.getServiceComponentName().equals("NAMENODE")) {
namenodeFailedEvent=event;
}
}
}
Assert.assertNotNull("Datanode should be in Install failed state.",datanodeFailedEvent);
Assert.assertNotNull("Namenode should be in Install failed state.",namenodeFailedEvent);
}
InternalCallVerifier EqualityVerifier hosts=new HashMap();
hosts.put(hostname,sch);
when(scomp.getServiceComponentHosts()).thenReturn(hosts);
long requestId=1;
final List stages=new ArrayList();
int namenodeCmdTaskId=1;
stages.add(getStageWithSingleTask(hostname,"cluster1",Role.NAMENODE,RoleCommand.START,Service.Type.HDFS,namenodeCmdTaskId,1,(int)requestId));
stages.add(getStageWithSingleTask(hostname,"cluster1",Role.DATANODE,RoleCommand.START,Service.Type.HDFS,2,2,(int)requestId));
Host host=mock(Host.class);
when(fsm.getHost(anyString())).thenReturn(host);
when(host.getState()).thenReturn(HostState.HEALTHY);
when(host.getHostName()).thenReturn(hostname);
ActionDBAccessor db=mock(ActionDBAccessor.class);
RequestEntity request=mock(RequestEntity.class);
when(request.isExclusive()).thenReturn(false);
when(db.getRequestEntity(anyLong())).thenReturn(request);
when(db.getCommandsInProgressCount()).thenReturn(stages.size());
when(db.getStagesInProgress()).thenReturn(stages);
List requestTasks=new ArrayList();
for ( Stage stage : stages) {
requestTasks.addAll(stage.getOrderedHostRoleCommands());
}
when(db.getRequestTasks(anyLong())).thenReturn(requestTasks);
when(db.getAllStages(anyLong())).thenReturn(stages);
doAnswer(new Answer(){
@Override public Void answer( InvocationOnMock invocation) throws Throwable {
List reports=(List)invocation.getArguments()[0];
for ( CommandReport report : reports) {
String actionId=report.getActionId();
long[] requestStageIds=StageUtils.getRequestStage(actionId);
Long requestId=requestStageIds[0];
Long stageId=requestStageIds[1];
Long id=report.getTaskId();
for ( Stage stage : stages) {
if (requestId.equals(stage.getRequestId()) && stageId.equals(stage.getStageId())) {
for ( HostRoleCommand hostRoleCommand : stage.getOrderedHostRoleCommands()) {
if (hostRoleCommand.getTaskId() == id) {
hostRoleCommand.setStatus(HostRoleStatus.valueOf(report.getStatus()));
}
}
}
}
}
return null;
}
}
).when(db).updateHostRoleStates(anyCollectionOf(CommandReport.class));
when(db.getTask(anyLong())).thenAnswer(new Answer(){
@Override public Object answer( InvocationOnMock invocation) throws Throwable {
Long taskId=(Long)invocation.getArguments()[0];
for ( Stage stage : stages) {
for ( HostRoleCommand command : stage.getOrderedHostRoleCommands()) {
if (taskId.equals(command.getTaskId())) {
return command;
}
}
}
return null;
}
}
);
doAnswer(new Answer(){
@Override public Void answer( InvocationOnMock invocation) throws Throwable {
Long requestId=(Long)invocation.getArguments()[0];
for ( Stage stage : stages) {
if (requestId.equals(stage.getRequestId())) {
for ( HostRoleCommand command : stage.getOrderedHostRoleCommands()) {
if (command.getStatus() == HostRoleStatus.QUEUED || command.getStatus() == HostRoleStatus.IN_PROGRESS || command.getStatus() == HostRoleStatus.PENDING) {
command.setStatus(HostRoleStatus.ABORTED);
}
}
}
}
return null;
}
}
).when(db).abortOperation(anyLong());
Properties properties=new Properties();
Configuration conf=new Configuration(properties);
ActionScheduler scheduler=new ActionScheduler(100,50,db,aq,fsm,3,new HostsMap((String)null),unitOfWork,null,conf);
scheduler.doWork();
String reason="Some reason";
scheduler.scheduleCancellingRequest(requestId,reason);
scheduler.doWork();
Assert.assertEquals(HostRoleStatus.ABORTED,stages.get(0).getHostRoleStatus(hostname,"NAMENODE"));
Assert.assertEquals(HostRoleStatus.ABORTED,stages.get(1).getHostRoleStatus(hostname,"DATANODE"));
Assert.assertEquals(aq.size(hostname),1);
CancelCommand cancelCommand=(CancelCommand)aq.dequeue(hostname);
Assert.assertEquals(cancelCommand.getTargetTaskId(),namenodeCmdTaskId);
Assert.assertEquals(cancelCommand.getReason(),reason);
}
IterativeVerifier InternalCallVerifier EqualityVerifier hosts=new HashMap();
hosts.put(host1,sch);
hosts.put(host2,sch);
when(scomp.getServiceComponentHosts()).thenReturn(hosts);
when(fsm.getHost(anyString())).thenReturn(host);
when(host.getState()).thenReturn(HostState.HEALTHY);
when(host.getHostName()).thenReturn(host1);
HostEntity hostEntity1=new HostEntity();
HostEntity hostEntity2=new HostEntity();
hostEntity1.setHostName(host1);
hostEntity2.setHostName(host2);
hostDAO.create(hostEntity1);
hostDAO.create(hostEntity2);
final List stages=new ArrayList();
long now=System.currentTimeMillis();
Stage stage=stageFactory.createNew(1,"/tmp","cluster1",1L,"testRequestFailureBasedOnSuccessFactor",CLUSTER_HOST_INFO,"","");
stage.setStageId(1);
addHostRoleExecutionCommand(now,stage,Role.SQOOP,Service.Type.SQOOP,RoleCommand.INSTALL,host1,"cluster1");
addHostRoleExecutionCommand(now,stage,Role.OOZIE_CLIENT,Service.Type.OOZIE,RoleCommand.INSTALL,host1,"cluster1");
addHostRoleExecutionCommand(now,stage,Role.MAPREDUCE_CLIENT,Service.Type.MAPREDUCE,RoleCommand.INSTALL,host1,"cluster1");
addHostRoleExecutionCommand(now,stage,Role.HBASE_CLIENT,Service.Type.HBASE,RoleCommand.INSTALL,host1,"cluster1");
addHostRoleExecutionCommand(now,stage,Role.GANGLIA_MONITOR,Service.Type.GANGLIA,RoleCommand.INSTALL,host1,"cluster1");
addHostRoleExecutionCommand(now,stage,Role.HBASE_CLIENT,Service.Type.HBASE,RoleCommand.INSTALL,host2,"cluster1");
addHostRoleExecutionCommand(now,stage,Role.GANGLIA_MONITOR,Service.Type.GANGLIA,RoleCommand.INSTALL,host2,"cluster1");
stages.add(stage);
HostRoleStatus[] statusesAtIterOne={HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED};
for (int index=0; index < stage.getOrderedHostRoleCommands().size(); index++) {
stage.getOrderedHostRoleCommands().get(index).setTaskId(index + 1);
stage.getOrderedHostRoleCommands().get(index).setStatus(statusesAtIterOne[index]);
}
stage.setLastAttemptTime(host1,Role.SQOOP.toString(),now);
stage.setLastAttemptTime(host1,Role.MAPREDUCE_CLIENT.toString(),now);
stage.setLastAttemptTime(host1,Role.OOZIE_CLIENT.toString(),now);
stage.setLastAttemptTime(host1,Role.GANGLIA_MONITOR.toString(),now);
stage.setLastAttemptTime(host1,Role.HBASE_CLIENT.toString(),now);
stage.setLastAttemptTime(host2,Role.GANGLIA_MONITOR.toString(),now);
stage.setLastAttemptTime(host2,Role.HBASE_CLIENT.toString(),now);
ActionDBAccessor db=mock(ActionDBAccessor.class);
RequestEntity request=mock(RequestEntity.class);
when(request.isExclusive()).thenReturn(false);
when(db.getRequestEntity(anyLong())).thenReturn(request);
when(db.getCommandsInProgressCount()).thenReturn(stages.size());
when(db.getStagesInProgress()).thenReturn(stages);
doAnswer(new Answer(){
@Override public Void answer( InvocationOnMock invocation) throws Throwable {
String host=(String)invocation.getArguments()[0];
Long requestId=(Long)invocation.getArguments()[1];
Long stageId=(Long)invocation.getArguments()[2];
String role=(String)invocation.getArguments()[3];
CommandReport commandReport=(CommandReport)invocation.getArguments()[4];
for ( Stage stage : stages) {
if (requestId.equals(stage.getRequestId()) && stageId.equals(stage.getStageId())) {
HostRoleCommand command=stage.getHostRoleCommand(host,role);
command.setStatus(HostRoleStatus.valueOf(commandReport.getStatus()));
}
}
return null;
}
}
).when(db).updateHostRoleState(anyString(),anyLong(),anyLong(),anyString(),any(CommandReport.class));
when(db.getTask(anyLong())).thenAnswer(new Answer(){
@Override public Object answer( InvocationOnMock invocation) throws Throwable {
Long taskId=(Long)invocation.getArguments()[0];
for ( Stage stage : stages) {
for ( HostRoleCommand command : stage.getOrderedHostRoleCommands()) {
if (taskId.equals(command.getTaskId())) {
return command;
}
}
}
return null;
}
}
);
doAnswer(new Answer(){
@Override public Void answer( InvocationOnMock invocation) throws Throwable {
Long requestId=(Long)invocation.getArguments()[0];
for ( Stage stage : stages) {
if (requestId.equals(stage.getRequestId())) {
for ( HostRoleCommand command : stage.getOrderedHostRoleCommands()) {
if (command.getStatus() == HostRoleStatus.QUEUED || command.getStatus() == HostRoleStatus.IN_PROGRESS || command.getStatus() == HostRoleStatus.PENDING) {
command.setStatus(HostRoleStatus.ABORTED);
}
}
}
}
return null;
}
}
).when(db).abortOperation(anyLong());
Properties properties=new Properties();
Configuration conf=new Configuration(properties);
ActionScheduler scheduler=new ActionScheduler(100,10000,db,aq,fsm,3,new HostsMap((String)null),unitOfWork,null,conf);
scheduler.doWork();
HostRoleStatus[] expectedStatusesAtIterOne={HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED};
for (int index=0; index < stage.getOrderedHostRoleCommands().size(); index++) {
log.info(stage.getOrderedHostRoleCommands().get(index).toString());
Assert.assertEquals(expectedStatusesAtIterOne[index],stage.getOrderedHostRoleCommands().get(index).getStatus());
}
HostRoleStatus[] statusesAtIterTwo={HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.QUEUED,HostRoleStatus.COMPLETED};
for (int index=0; index < stage.getOrderedHostRoleCommands().size(); index++) {
stage.getOrderedHostRoleCommands().get(index).setStatus(statusesAtIterTwo[index]);
}
scheduler.doWork();
HostRoleStatus[] expectedStatusesAtIterTwo={HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.QUEUED,HostRoleStatus.COMPLETED};
for (int index=0; index < stage.getOrderedHostRoleCommands().size(); index++) {
log.info(stage.getOrderedHostRoleCommands().get(index).toString());
Assert.assertEquals(expectedStatusesAtIterTwo[index],stage.getOrderedHostRoleCommands().get(index).getStatus());
}
HostRoleStatus[] statusesAtIterThree={HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.QUEUED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.COMPLETED};
for (int index=0; index < stage.getOrderedHostRoleCommands().size(); index++) {
stage.getOrderedHostRoleCommands().get(index).setStatus(statusesAtIterThree[index]);
}
scheduler.doWork();
HostRoleStatus[] expectedStatusesAtIterThree={HostRoleStatus.ABORTED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.COMPLETED};
for (int index=0; index < stage.getOrderedHostRoleCommands().size(); index++) {
log.info(stage.getOrderedHostRoleCommands().get(index).toString());
Assert.assertEquals(expectedStatusesAtIterThree[index],stage.getOrderedHostRoleCommands().get(index).getStatus());
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier >>(){
}
.getType();
Map> clusterHostInfo=StageUtils.getGson().fromJson(CLUSTER_HOST_INFO,type);
ActionQueue aq=new ActionQueue();
Properties properties=new Properties();
Configuration conf=new Configuration(properties);
Clusters fsm=mock(Clusters.class);
Cluster oneClusterMock=mock(Cluster.class);
Service serviceObj=mock(Service.class);
ServiceComponent scomp=mock(ServiceComponent.class);
ServiceComponentHost sch=mock(ServiceComponentHost.class);
UnitOfWork unitOfWork=mock(UnitOfWork.class);
when(fsm.getCluster(anyString())).thenReturn(oneClusterMock);
when(fsm.getClusterById(anyLong())).thenReturn(oneClusterMock);
when(oneClusterMock.getService(anyString())).thenReturn(serviceObj);
when(oneClusterMock.getClusterId()).thenReturn(Long.valueOf(1L));
when(serviceObj.getServiceComponent(anyString())).thenReturn(scomp);
when(scomp.getServiceComponentHost(anyString())).thenReturn(sch);
when(serviceObj.getCluster()).thenReturn(oneClusterMock);
Host host=mock(Host.class);
HashMap hosts=new HashMap();
hosts.put(hostname,sch);
HostEntity hostEntity=new HostEntity();
hostEntity.setHostName(hostname);
hostDAO.merge(hostEntity);
when(scomp.getServiceComponentHosts()).thenReturn(hosts);
when(fsm.getHost(anyString())).thenReturn(host);
when(host.getState()).thenReturn(HostState.HEALTHY);
when(host.getHostName()).thenReturn(hostname);
ActionDBAccessor db=mock(ActionDBAccessorImpl.class);
List stages=new ArrayList();
Stage s=StageUtils.getATestStage(1,977,hostname,CLUSTER_HOST_INFO,"{\"host_param\":\"param_value\"}","{\"stage_param\":\"param_value\"}");
stages.add(s);
when(db.getCommandsInProgressCount()).thenReturn(stages.size());
when(db.getStagesInProgress()).thenReturn(stages);
RequestEntity request=mock(RequestEntity.class);
when(request.isExclusive()).thenReturn(false);
when(db.getRequestEntity(anyLong())).thenReturn(request);
ActionScheduler scheduler=new ActionScheduler(100,5,db,aq,fsm,10000,new HostsMap((String)null),unitOfWork,null,conf);
scheduler.setTaskTimeoutAdjustment(false);
List ac=waitForQueueSize(hostname,aq,1,scheduler);
assertTrue(ac.get(0) instanceof ExecutionCommand);
assertEquals("1-977",((ExecutionCommand)(ac.get(0))).getCommandId());
assertEquals(clusterHostInfo,((ExecutionCommand)(ac.get(0))).getClusterHostInfo());
ac=waitForQueueSize(hostname,aq,1,scheduler);
assertTrue(ac.get(0) instanceof ExecutionCommand);
assertEquals("1-977",((ExecutionCommand)(ac.get(0))).getCommandId());
assertEquals(clusterHostInfo,((ExecutionCommand)(ac.get(0))).getClusterHostInfo());
s.setHostRoleStatus(hostname,"NAMENODE",HostRoleStatus.COMPLETED);
ac=aq.dequeueAll(hostname);
ac=waitForQueueSize(hostname,aq,0,scheduler);
}
InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.actionmanager.TestStage InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier commandParams=new TreeMap();
commandParams.put(ExecutionCommand.KeyNames.COMMAND_TIMEOUT,"600");
wrapper.getExecutionCommand().setCommandParams(commandParams);
}
assertEquals(3 * 600000,s.getStageTimeout());
}
Class: org.apache.ambari.server.agent.AgentHostInfoTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.agent.AgentResourceTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.agent.TestActionQueue IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier producers=new ArrayList();
List consumers=new ArrayList();
for (int i=0; i < threadCount; i++) {
dequeOperators[i]=new ActionQueueOperation(aq,hosts,ActionQueueOperation.OpType.DEQUEUE);
Thread t=new Thread(dequeOperators[i]);
consumers.add(t);
t.start();
}
for (int i=0; i < threadCount; i++) {
enqueOperators[i]=new ActionQueueOperation(aq,hosts,ActionQueueOperation.OpType.ENQUEUE);
Thread t=new Thread(enqueOperators[i]);
producers.add(t);
t.start();
}
for (int i=0; i < threadCount; i++) {
dequeAllOperators[i]=new ActionQueueOperation(aq,hosts,ActionQueueOperation.OpType.DEQUEUEALL);
Thread t=new Thread(dequeAllOperators[i]);
consumers.add(t);
t.start();
}
Thread.sleep(100);
for (int i=0; i < threadCount; i++) {
enqueOperators[i].stop();
}
for ( Thread producer : producers) {
producer.join();
}
boolean allDequeued=false;
while (!allDequeued) {
Thread.sleep(10);
allDequeued=true;
for ( String host : hosts) {
if (aq.size(host) > 0) {
allDequeued=false;
break;
}
}
}
for (int i=0; i < threadCount; i++) {
dequeOperators[i].stop();
dequeAllOperators[i].stop();
}
for ( Thread consumer : consumers) {
consumer.join();
}
for (int h=0; h < hosts.length; h++) {
long opsEnqueued=0;
long opsDequeued=0;
for (int i=0; i < threadCount; i++) {
opsEnqueued+=enqueOperators[i].getOpCounts()[h];
opsDequeued+=dequeOperators[i].getOpCounts()[h];
opsDequeued+=dequeAllOperators[i].getOpCounts()[h];
}
assertTrue(opsEnqueued != 0);
assertEquals(0,aq.size(hosts[h]));
LOG.info("Host: " + hosts[h] + ", opsEnqueued: "+ opsEnqueued+ ", opsDequeued: "+ opsDequeued);
assertEquals(opsDequeued,opsEnqueued);
}
}
InternalCallVerifier BooleanVerifier producers=new ArrayList();
List consumers=new ArrayList();
for (int i=0; i < threadCount; i++) {
hostCheckers[i]=new ActionQueueOperation(aq,hosts,ActionQueueOperation.OpType.CHECKPENDING);
Thread t=new Thread(hostCheckers[i]);
consumers.add(t);
t.start();
}
for (int i=0; i < threadCount; i++) {
hostUpdaters[i]=new ActionQueueOperation(aq,hosts,ActionQueueOperation.OpType.UPDATEHOSTLIST);
Thread t=new Thread(hostUpdaters[i]);
producers.add(t);
t.start();
}
Thread.sleep(100);
for (int i=0; i < threadCount; i++) {
hostUpdaters[i].stop();
}
for ( Thread producer : producers) {
producer.join();
}
for (int i=0; i < threadCount; i++) {
hostCheckers[i].stop();
}
for ( Thread consumer : consumers) {
consumer.join();
}
int totalChecks=0;
int totalUpdates=0;
for (int i=0; i < threadCount; i++) {
totalChecks+=hostUpdaters[i].getOpCounts()[0];
for (int h=0; h < hosts.length; h++) {
totalUpdates+=hostCheckers[i].getOpCounts()[h];
}
}
LOG.info("Report: totalChecks: " + totalChecks + ", totalUpdates: "+ totalUpdates);
HashSet hostsWithPendingtasks=new HashSet();
aq.updateListOfHostsWithPendingTask(hostsWithPendingtasks);
hostsWithPendingtasks.add("h1");
aq.updateListOfHostsWithPendingTask(hostsWithPendingtasks);
assertTrue(aq.hasPendingTask("h1"));
assertFalse(aq.hasPendingTask("h2"));
hostsWithPendingtasks.add("h1");
hostsWithPendingtasks.add("h2");
aq.updateListOfHostsWithPendingTask(hostsWithPendingtasks);
assertTrue(aq.hasPendingTask("h1"));
assertTrue(aq.hasPendingTask("h2"));
hostsWithPendingtasks.clear();
hostsWithPendingtasks.add("h2");
aq.updateListOfHostsWithPendingTask(hostsWithPendingtasks);
assertFalse(aq.hasPendingTask("h1"));
assertTrue(aq.hasPendingTask("h2"));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier commands=queue.dequeue(c6401,AgentCommandType.ALERT_DEFINITION_COMMAND);
assertNotNull(commands);
assertEquals(3,commands.size());
assertEquals(4,queue.size(c6401));
assertEquals(3,queue.size(c6402));
}
Class: org.apache.ambari.server.agent.TestHeartbeatHandler InternalCallVerifier BooleanVerifier config=rr.getAgentConfig();
assertFalse(config.isEmpty());
assertTrue(config.containsKey(Configuration.CHECK_REMOTE_MOUNTS_KEY));
assertTrue("false".equals(config.get(Configuration.CHECK_REMOTE_MOUNTS_KEY)));
assertTrue(config.containsKey(Configuration.CHECK_MOUNTS_TIMEOUT_KEY));
assertTrue("0".equals(config.get(Configuration.CHECK_MOUNTS_TIMEOUT_KEY)));
assertTrue("true".equals(config.get(Configuration.ENABLE_AUTO_AGENT_CACHE_UPDATE_KEY)));
}
InternalCallVerifier EqualityVerifier ());
ArrayList componentStatuses=new ArrayList();
ComponentStatus componentStatus1=new ComponentStatus();
componentStatus1.setClusterName(DummyCluster);
componentStatus1.setServiceName(HDFS);
componentStatus1.setMessage(DummyHostStatus);
componentStatus1.setStatus(State.STARTED.name());
componentStatus1.setSecurityState(SecurityState.UNSECURED.name());
componentStatus1.setComponentName(DATANODE);
componentStatuses.add(componentStatus1);
ComponentStatus componentStatus2=new ComponentStatus();
componentStatus2.setClusterName(DummyCluster);
componentStatus2.setServiceName(HDFS);
componentStatus2.setMessage(DummyHostStatus);
componentStatus2.setStatus(State.INSTALLED.name());
componentStatus2.setSecurityState(SecurityState.UNSECURED.name());
componentStatus2.setComponentName(NAMENODE);
componentStatuses.add(componentStatus2);
hb.setComponentStatus(componentStatuses);
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
State componentState1=serviceComponentHost1.getState();
State componentState2=serviceComponentHost2.getState();
assertEquals(State.STARTED,componentState1);
assertEquals(State.INSTALLED,componentState2);
}
InternalCallVerifier EqualityVerifier reports=new ArrayList();
reports.add(cr1);
reports.add(cr2);
hb.setReports(reports);
ActionQueue aq=new ActionQueue();
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
assertEquals("State of SCH not change while operation is in progress",State.UPGRADING,serviceComponentHost1.getState());
assertEquals("Stack version of SCH should not change after in progress report",stack130,serviceComponentHost1.getDesiredStackVersion());
assertEquals("State of SCH not change while operation is in progress",State.INSTALLING,serviceComponentHost2.getState());
}
InternalCallVerifier EqualityVerifier stages=new ArrayList();
stages.add(s);
Request request=new Request(stages,clusters);
actionDBAccessor.persistActions(request);
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setTaskId(1);
cr.setClusterName(DummyCluster);
cr.setServiceName(HDFS);
cr.setRole(DATANODE);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setStdErr("none");
cr.setStdOut("dummy output");
actionDBAccessor.updateHostRoleState(DummyHostname1,requestId,stageId,Role.DATANODE.name(),cr);
cr.setRole(NAMENODE);
cr.setTaskId(2);
actionDBAccessor.updateHostRoleState(DummyHostname1,requestId,stageId,Role.NAMENODE.name(),cr);
HeartBeat hb=new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
CommandReport cr1=new CommandReport();
cr1.setActionId(StageUtils.getActionId(requestId,stageId));
cr1.setTaskId(1);
cr1.setClusterName(DummyCluster);
cr1.setServiceName(HDFS);
cr1.setRole(DATANODE);
cr1.setRoleCommand("INSTALL");
cr1.setStatus(HostRoleStatus.FAILED.toString());
cr1.setStdErr("none");
cr1.setStdOut("dummy output");
cr1.setExitCode(0);
CommandReport cr2=new CommandReport();
cr2.setActionId(StageUtils.getActionId(requestId,stageId));
cr2.setTaskId(2);
cr2.setClusterName(DummyCluster);
cr2.setServiceName(HDFS);
cr2.setRole(NAMENODE);
cr2.setRoleCommand("INSTALL");
cr2.setStatus(HostRoleStatus.FAILED.toString());
cr2.setStdErr("none");
cr2.setStdOut("dummy output");
cr2.setExitCode(0);
ArrayList reports=new ArrayList();
reports.add(cr1);
reports.add(cr2);
hb.setReports(reports);
ActionQueue aq=new ActionQueue();
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
assertEquals("State of SCH should change after fail report",State.UPGRADING,serviceComponentHost1.getState());
assertEquals("State of SCH should change after fail report",State.INSTALL_FAILED,serviceComponentHost2.getState());
assertEquals("Stack version of SCH should not change after fail report",stack120,serviceComponentHost1.getStackVersion());
assertEquals("Stack version of SCH should not change after fail report",stack130,serviceComponentHost1.getDesiredStackVersion());
assertEquals("Stack version of SCH should not change after fail report",State.INSTALL_FAILED,serviceComponentHost2.getState());
}
InternalCallVerifier EqualityVerifier ());
ArrayList componentStatuses=new ArrayList();
ComponentStatus componentStatus1=new ComponentStatus();
componentStatus1.setClusterName(DummyCluster);
componentStatus1.setServiceName(HDFS);
componentStatus1.setMessage(DummyHostStatus);
componentStatus1.setStatus(State.STARTED.name());
componentStatus1.setSecurityState(SecurityState.SECURED_KERBEROS.name());
componentStatus1.setComponentName(DATANODE);
componentStatuses.add(componentStatus1);
ComponentStatus componentStatus2=new ComponentStatus();
componentStatus2.setClusterName(DummyCluster);
componentStatus2.setServiceName(HDFS);
componentStatus2.setMessage(DummyHostStatus);
componentStatus2.setStatus(State.STARTED.name());
componentStatus2.setSecurityState(SecurityState.UNSECURED.name());
componentStatus2.setComponentName(SECONDARY_NAMENODE);
componentStatuses.add(componentStatus2);
hb.setComponentStatus(componentStatuses);
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
State componentState1=serviceComponentHost1.getState();
State componentState2=serviceComponentHost2.getState();
State componentState3=serviceComponentHost3.getState();
assertEquals(State.STARTED,componentState1);
assertEquals(SecurityState.SECURED_KERBEROS,serviceComponentHost1.getSecurityState());
assertEquals(State.INSTALLED,componentState2);
assertEquals(SecurityState.SECURING,serviceComponentHost2.getSecurityState());
assertEquals(State.STARTED,componentState3);
assertEquals(SecurityState.UNSECURED,serviceComponentHost3.getSecurityState());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier stages=new ArrayList();
stages.add(s);
Request request=new Request(stages,clusters);
actionDBAccessor.persistActions(request);
actionDBAccessor.abortHostRole(DummyHostname1,1,1,Role.DATANODE.name());
HeartBeat hb=new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(0);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
List reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(1,1));
cr.setTaskId(1);
cr.setClusterName(DummyCluster);
cr.setServiceName(HDFS);
cr.setRole(DATANODE);
cr.setRoleCommand("INSTALL");
cr.setStatus("FAILED");
cr.setStdErr("none");
cr.setStdOut("dummy output");
cr.setExitCode(777);
reports.add(cr);
hb.setReports(reports);
hb.setComponentStatus(new ArrayList());
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
State componentState1=serviceComponentHost1.getState();
assertEquals("Host state should still be installing",State.INSTALLING,componentState1);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setServiceName(HDFS);
cr.setRoleCommand("CUSTOM_COMMAND");
cr.setCustomCommand("START");
cr.setTaskId(1);
cr.setRole(DATANODE);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setClusterName(DummyCluster);
CommandReport crn=new CommandReport();
crn.setActionId(StageUtils.getActionId(requestId,stageId));
crn.setServiceName(HDFS);
crn.setRoleCommand("CUSTOM_COMMAND");
crn.setCustomCommand("STOP");
crn.setTaskId(1);
crn.setRole(NAMENODE);
crn.setStatus("COMPLETED");
crn.setStdErr("");
crn.setStdOut("");
crn.setExitCode(215);
crn.setClusterName(DummyCluster);
reports.add(cr);
reports.add(crn);
hb.setReports(reports);
assertTrue(serviceComponentHost1.isRestartRequired());
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
State componentState1=serviceComponentHost1.getState();
assertEquals(State.STARTED,componentState1);
assertFalse(serviceComponentHost1.isRestartRequired());
State componentState2=serviceComponentHost2.getState();
assertEquals(State.INSTALLED,componentState2);
assertTrue(serviceComponentHost2.isRestartRequired());
}
InternalCallVerifier EqualityVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setTaskId(1);
cr.setClusterName(DummyCluster);
cr.setServiceName(HDFS);
cr.setRole(DATANODE);
cr.setRoleCommand("INSTALL");
cr.setStatus("IN_PROGRESS");
cr.setStdErr("none");
cr.setStdOut("dummy output");
cr.setExitCode(777);
reports.add(cr);
hb.setReports(reports);
hb.setComponentStatus(new ArrayList());
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,RoleCommand.INSTALL);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
State componentState1=serviceComponentHost1.getState();
assertEquals("Host state should still be installing",State.INSTALLING,componentState1);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier ());
hb.setAgentEnv(new AgentEnv());
hb.setMounts(new ArrayList());
ArrayList componentStatuses=new ArrayList();
ComponentStatus componentStatus1=createComponentStatus(DummyCluster,HDFS,DummyHostStatus,State.STARTED,SecurityState.UNSECURED,DATANODE,"{\"stackName\":\"HDP\",\"stackVersion\":\"1.3.0\"}");
ComponentStatus componentStatus2=createComponentStatus(DummyCluster,HDFS,DummyHostStatus,State.STARTED,SecurityState.UNSECURED,NAMENODE,"");
ComponentStatus componentStatus3=createComponentStatus(DummyCluster,HDFS,DummyHostStatus,State.INSTALLED,SecurityState.UNSECURED,HDFS_CLIENT,"{\"stackName\":\"HDP\",\"stackVersion\":\"1.3.0\"}");
componentStatuses.add(componentStatus1);
componentStatuses.add(componentStatus2);
componentStatuses.add(componentStatus3);
hb.setComponentStatus(componentStatuses);
ActionQueue aq=new ActionQueue();
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
assertEquals("Matching value " + serviceComponentHost1.getStackVersion(),stack130,serviceComponentHost1.getStackVersion());
assertEquals("Matching value " + serviceComponentHost2.getStackVersion(),stack120,serviceComponentHost2.getStackVersion());
assertEquals("Matching value " + serviceComponentHost3.getStackVersion(),stack130,serviceComponentHost3.getStackVersion());
assertTrue(hb.getAgentEnv().getHostHealth().getServerTimeStampAtReporting() >= hb.getTimestamp());
}
InternalCallVerifier EqualityVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setTaskId(1);
cr.setClusterName(DummyCluster);
cr.setServiceName(HDFS);
cr.setRole(DATANODE);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setStdErr("none");
cr.setStdOut("dummy output");
cr.setExitCode(777);
cr.setRoleCommand("START");
reports.add(cr);
hb.setReports(reports);
hb.setComponentStatus(new ArrayList());
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
}
}
).anyTimes();
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.INSTALLED,State.INSTALLED,serviceComponentHost1.getState());
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(1);
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.STARTED,State.STARTED,serviceComponentHost1.getState());
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(2);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setRoleCommand("STOP");
cr.setExitCode(777);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.STARTED,State.STARTED,serviceComponentHost1.getState());
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(3);
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.INSTALLED,State.INSTALLED,serviceComponentHost1.getState());
serviceComponentHost1.setState(State.STARTING);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setExitCode(777);
cr.setRoleCommand("START");
hb.setResponseId(4);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.STARTING,State.STARTING,serviceComponentHost1.getState());
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
hb.setResponseId(5);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.STARTED,State.STARTED,serviceComponentHost1.getState());
serviceComponentHost1.setState(State.STOPPING);
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setExitCode(777);
cr.setRoleCommand("STOP");
hb.setResponseId(6);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.STOPPING,State.STOPPING,serviceComponentHost1.getState());
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
hb.setResponseId(7);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.INSTALLED,State.INSTALLED,serviceComponentHost1.getState());
}
InternalCallVerifier EqualityVerifier > dummyComponents=new HashMap>();
Map dummyCategoryMap=new HashMap();
dummyCategoryMap.put("PIG","CLIENT");
dummyComponents.put("PIG",dummyCategoryMap);
dummyCategoryMap=new HashMap();
dummyCategoryMap.put("MAPREDUCE_CLIENT","CLIENT");
dummyCategoryMap.put("JOBTRACKER","MASTER");
dummyCategoryMap.put("TASKTRACKER","SLAVE");
dummyComponents.put("MAPREDUCE",dummyCategoryMap);
dummyCategoryMap=new HashMap();
dummyCategoryMap.put("DATANODE2","SLAVE");
dummyCategoryMap.put("NAMENODE","MASTER");
dummyCategoryMap.put("HDFS_CLIENT","CLIENT");
dummyCategoryMap.put("DATANODE1","SLAVE");
dummyCategoryMap.put("SECONDARY_NAMENODE","MASTER");
dummyCategoryMap.put("DATANODE","SLAVE");
dummyComponents.put("HDFS",dummyCategoryMap);
expected.setClusterName(DummyCluster);
expected.setStackName(dummyStackId.getStackName());
expected.setStackVersion(dummyStackId.getStackVersion());
expected.setComponents(dummyComponents);
getDummyCluster();
HeartBeatHandler handler=getHeartBeatHandler(getMockActionManager(),new ActionQueue());
ComponentsResponse actual=handler.handleComponents(DummyCluster);
if (log.isDebugEnabled()) {
log.debug(actual.toString());
}
assertEquals(expected.getClusterName(),actual.getClusterName());
assertEquals(expected.getStackName(),actual.getStackName());
assertEquals(expected.getStackVersion(),actual.getStackVersion());
assertEquals(expected.getComponents(),actual.getComponents());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier ());
ArrayList componentStatuses=new ArrayList();
hb.setComponentStatus(componentStatuses);
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
}
}
).anyTimes();
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
HeartBeatResponse resp=handler.handleHeartBeat(hb);
Assert.assertFalse(resp.hasMappedComponents());
hdfs.getServiceComponent(DATANODE).addServiceComponentHost(DummyHostname1).persist();
ServiceComponentHost serviceComponentHost1=clusters.getCluster(DummyCluster).getService(HDFS).getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
serviceComponentHost1.setState(State.INIT);
hb=new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(1);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb.setReports(new ArrayList());
hb.setComponentStatus(componentStatuses);
resp=handler.handleHeartBeat(hb);
Assert.assertTrue(resp.hasMappedComponents());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setServiceName(HDFS);
cr.setRoleCommand("CUSTOM_COMMAND");
cr.setCustomCommand("RESTART");
cr.setTaskId(1);
cr.setRole(DATANODE);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setClusterName(DummyCluster);
cr.setConfigurationTags(new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
);
CommandReport crn=new CommandReport();
crn.setActionId(StageUtils.getActionId(requestId,stageId));
crn.setServiceName(HDFS);
crn.setRoleCommand("CUSTOM_COMMAND");
crn.setCustomCommand("START");
crn.setTaskId(1);
crn.setRole(NAMENODE);
crn.setStatus("COMPLETED");
crn.setStdErr("");
crn.setStdOut("");
crn.setExitCode(215);
crn.setClusterName(DummyCluster);
crn.setConfigurationTags(new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
);
reports.add(cr);
reports.add(crn);
hb.setReports(reports);
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
Assert.assertNotNull(serviceComponentHost1.getActualConfigs());
Assert.assertEquals(serviceComponentHost1.getActualConfigs().size(),1);
Assert.assertNotNull(serviceComponentHost2.getActualConfigs());
Assert.assertEquals(serviceComponentHost2.getActualConfigs().size(),1);
}
InternalCallVerifier NullVerifier ());
StackId stackId=new StackId("HDP","0.1");
RepositoryVersionDAO dao=injector.getInstance(RepositoryVersionDAO.class);
RepositoryVersionEntity entity=dao.findByStackAndVersion(stackId,"0.1");
Assert.assertNotNull(entity);
handler.handleHeartBeat(hb);
entity=dao.findByStackAndVersion(stackId,"0.1");
Assert.assertNull(entity);
entity=dao.findByStackAndVersion(stackId,"2.2.1.0-2222");
Assert.assertNotNull(entity);
}
InternalCallVerifier EqualityVerifier ());
List> procs=new ArrayList>();
Map proc1info=new HashMap();
proc1info.put("name","a");
proc1info.put("status","RUNNING");
procs.add(proc1info);
Map proc2info=new HashMap();
proc2info.put("name","b");
proc2info.put("status","NOT_RUNNING");
procs.add(proc2info);
Map extra=new HashMap();
extra.put("processes",procs);
ArrayList componentStatuses=new ArrayList();
ComponentStatus componentStatus1=new ComponentStatus();
componentStatus1.setClusterName(DummyCluster);
componentStatus1.setServiceName(HDFS);
componentStatus1.setMessage(DummyHostStatus);
componentStatus1.setStatus(State.STARTED.name());
componentStatus1.setSecurityState(SecurityState.UNSECURED.name());
componentStatus1.setComponentName(DATANODE);
componentStatus1.setExtra(extra);
componentStatuses.add(componentStatus1);
hb.setComponentStatus(componentStatuses);
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
}
}
).anyTimes();
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
ServiceComponentHost sch=hdfs.getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
Assert.assertEquals(Integer.valueOf(2),Integer.valueOf(sch.getProcesses().size()));
hb=new HeartBeat();
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(1);
hb.setHostname(DummyHostname1);
hb.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb.setReports(new ArrayList());
componentStatus1=new ComponentStatus();
componentStatus1.setClusterName(DummyCluster);
componentStatus1.setServiceName(HDFS);
componentStatus1.setMessage(DummyHostStatus);
componentStatus1.setStatus(State.STARTED.name());
componentStatus1.setSecurityState(SecurityState.UNSECURED.name());
componentStatus1.setComponentName(DATANODE);
hb.setComponentStatus(Collections.singletonList(componentStatus1));
handler.handleHeartBeat(hb);
}
InternalCallVerifier EqualityVerifier reports=new ArrayList();
reports.add(cr1);
reports.add(cr2);
hb.setReports(reports);
ActionQueue aq=new ActionQueue();
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
assertEquals("Stack version for SCH should be updated to " + serviceComponentHost1.getDesiredStackVersion(),stack130,serviceComponentHost1.getStackVersion());
assertEquals("Stack version for SCH should not change ",stack120,serviceComponentHost2.getStackVersion());
}
InternalCallVerifier EqualityVerifier (){
{
add(command);
add(command);
}
}
).anyTimes();
replay(am);
HeartBeatHandler handler=new HeartBeatHandler(fsm,aq,am,injector);
Register reg=new Register();
HostInfo hi=new HostInfo();
hi.setHostName(DummyHostname1);
hi.setOS(DummyOs);
hi.setOSRelease(DummyOSRelease);
reg.setHostname(DummyHostname1);
reg.setHardwareProfile(hi);
reg.setAgentVersion(metaInfo.getServerVersion());
handler.handleRegistration(reg);
hostObject.setState(HostState.UNHEALTHY);
aq.enqueue(DummyHostname1,new StatusCommand());
HeartBeat hb1=new HeartBeat();
hb1.setResponseId(0);
hb1.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb1.setHostname(DummyHostname1);
List componentStatus=new ArrayList();
ComponentStatus dataNodeStatus=new ComponentStatus();
dataNodeStatus.setClusterName(cluster.getClusterName());
dataNodeStatus.setServiceName(HDFS);
dataNodeStatus.setComponentName(DATANODE);
dataNodeStatus.setStatus("STARTED");
dataNodeStatus.setSecurityState(SecurityState.UNSECURED.name());
componentStatus.add(dataNodeStatus);
ComponentStatus nameNodeStatus=new ComponentStatus();
nameNodeStatus.setClusterName(cluster.getClusterName());
nameNodeStatus.setServiceName(HDFS);
nameNodeStatus.setComponentName(NAMENODE);
nameNodeStatus.setStatus("STARTED");
nameNodeStatus.setSecurityState(SecurityState.UNSECURED.name());
componentStatus.add(nameNodeStatus);
hb1.setComponentStatus(componentStatus);
handler.handleHeartBeat(hb1);
assertEquals(HostHealthStatus.HealthStatus.HEALTHY.name(),hostObject.getStatus());
HeartBeat hb2=new HeartBeat();
hb2.setResponseId(1);
hb2.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb2.setHostname(DummyHostname1);
componentStatus=new ArrayList();
dataNodeStatus=new ComponentStatus();
dataNodeStatus.setClusterName(cluster.getClusterName());
dataNodeStatus.setServiceName(HDFS);
dataNodeStatus.setComponentName(DATANODE);
dataNodeStatus.setStatus("INSTALLED");
dataNodeStatus.setSecurityState(SecurityState.UNSECURED.name());
componentStatus.add(dataNodeStatus);
nameNodeStatus=new ComponentStatus();
nameNodeStatus.setClusterName(cluster.getClusterName());
nameNodeStatus.setServiceName(HDFS);
nameNodeStatus.setComponentName(NAMENODE);
nameNodeStatus.setStatus("STARTED");
nameNodeStatus.setSecurityState(SecurityState.UNSECURED.name());
componentStatus.add(nameNodeStatus);
hb2.setComponentStatus(componentStatus);
handler.handleHeartBeat(hb2);
assertEquals(HostHealthStatus.HealthStatus.ALERT.name(),hostObject.getStatus());
hdfs.getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1).setMaintenanceState(MaintenanceState.ON);
HeartBeat hb2a=new HeartBeat();
hb2a.setResponseId(2);
hb2a.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb2a.setHostname(DummyHostname1);
componentStatus=new ArrayList();
dataNodeStatus=new ComponentStatus();
dataNodeStatus.setClusterName(cluster.getClusterName());
dataNodeStatus.setServiceName(HDFS);
dataNodeStatus.setComponentName(DATANODE);
dataNodeStatus.setStatus("INSTALLED");
dataNodeStatus.setSecurityState(SecurityState.UNSECURED.name());
componentStatus.add(dataNodeStatus);
nameNodeStatus=new ComponentStatus();
nameNodeStatus.setClusterName(cluster.getClusterName());
nameNodeStatus.setServiceName(HDFS);
nameNodeStatus.setComponentName(NAMENODE);
nameNodeStatus.setStatus("STARTED");
nameNodeStatus.setSecurityState(SecurityState.UNSECURED.name());
componentStatus.add(nameNodeStatus);
hb2a.setComponentStatus(componentStatus);
handler.handleHeartBeat(hb2a);
assertEquals(HostHealthStatus.HealthStatus.HEALTHY.name(),hostObject.getStatus());
hdfs.getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1).setMaintenanceState(MaintenanceState.OFF);
HeartBeat hb3=new HeartBeat();
hb3.setResponseId(3);
hb3.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb3.setHostname(DummyHostname1);
componentStatus=new ArrayList();
dataNodeStatus=new ComponentStatus();
dataNodeStatus.setClusterName(cluster.getClusterName());
dataNodeStatus.setServiceName(HDFS);
dataNodeStatus.setComponentName(DATANODE);
dataNodeStatus.setStatus("INSTALLED");
dataNodeStatus.setSecurityState(SecurityState.UNSECURED.name());
componentStatus.add(dataNodeStatus);
nameNodeStatus=new ComponentStatus();
nameNodeStatus.setClusterName(cluster.getClusterName());
nameNodeStatus.setServiceName(HDFS);
nameNodeStatus.setComponentName(NAMENODE);
nameNodeStatus.setStatus("INSTALLED");
nameNodeStatus.setSecurityState(SecurityState.UNSECURED.name());
componentStatus.add(nameNodeStatus);
hb3.setComponentStatus(componentStatus);
handler.handleHeartBeat(hb3);
assertEquals(HostHealthStatus.HealthStatus.UNHEALTHY.name(),hostObject.getStatus());
hb1.setResponseId(4);
handler.handleHeartBeat(hb1);
assertEquals(HostHealthStatus.HealthStatus.HEALTHY.name(),hostObject.getStatus());
reset(am);
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
}
}
).anyTimes();
replay(am);
hdfs.getServiceComponent(NAMENODE).getServiceComponentHost(DummyHostname1).setState(State.INSTALLED);
HeartBeat hb4=new HeartBeat();
hb4.setResponseId(5);
hb4.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb4.setHostname(DummyHostname1);
componentStatus=new ArrayList();
dataNodeStatus=new ComponentStatus();
dataNodeStatus.setClusterName(cluster.getClusterName());
dataNodeStatus.setServiceName(HDFS);
dataNodeStatus.setComponentName(DATANODE);
dataNodeStatus.setStatus("STARTED");
dataNodeStatus.setSecurityState(SecurityState.UNSECURED.name());
componentStatus.add(dataNodeStatus);
hb4.setComponentStatus(componentStatus);
handler.handleHeartBeat(hb4);
assertEquals(HostHealthStatus.HealthStatus.UNHEALTHY.name(),hostObject.getStatus());
hb1.setResponseId(6);
handler.handleHeartBeat(hb1);
assertEquals(HostHealthStatus.HealthStatus.HEALTHY.name(),hostObject.getStatus());
HeartBeat hb5=new HeartBeat();
hb5.setResponseId(7);
hb5.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb5.setHostname(DummyHostname1);
CommandReport cr1=new CommandReport();
cr1.setActionId(StageUtils.getActionId(requestId,stageId));
cr1.setServiceName(HDFS);
cr1.setTaskId(1);
cr1.setRole(DATANODE);
cr1.setStatus("COMPLETED");
cr1.setStdErr("");
cr1.setStdOut("");
cr1.setExitCode(215);
cr1.setRoleCommand("STOP");
cr1.setClusterName(DummyCluster);
ArrayList reports=new ArrayList();
reports.add(cr1);
hb5.setReports(reports);
handler.handleHeartBeat(hb5);
assertEquals(HostHealthStatus.HealthStatus.ALERT.name(),hostObject.getStatus());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier ());
ArrayList componentStatuses=new ArrayList();
ComponentStatus componentStatus1=new ComponentStatus();
componentStatus1.setClusterName(DummyCluster);
componentStatus1.setServiceName(HDFS);
componentStatus1.setMessage(DummyHostStatus);
componentStatus1.setStatus(State.STARTED.name());
componentStatus1.setSecurityState(SecurityState.UNSECURED.name());
componentStatus1.setComponentName(DATANODE);
componentStatuses.add(componentStatus1);
hb.setComponentStatus(componentStatuses);
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
ServiceComponentHost sch=hdfs.getServiceComponent(DATANODE).getServiceComponentHost(DummyHostname1);
Assert.assertEquals(Integer.valueOf(0),Integer.valueOf(sch.getProcesses().size()));
}
UtilityVerifier InternalCallVerifier BooleanVerifier HybridVerifier InternalCallVerifier EqualityVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setTaskId(1);
cr.setRole(HBASE_MASTER);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setConfigurationTags(new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
);
reports.add(cr);
am.processTaskResponse(DummyHostname1,reports,stage.getOrderedHostRoleCommands());
assertEquals(215,am.getAction(requestId,stageId).getExitCode(DummyHostname1,HBASE_MASTER));
assertEquals(HostRoleStatus.COMPLETED,am.getAction(requestId,stageId).getHostRoleStatus(DummyHostname1,HBASE_MASTER));
Stage s=db.getAllStages(requestId).get(0);
assertEquals(HostRoleStatus.COMPLETED,s.getHostRoleStatus(DummyHostname1,HBASE_MASTER));
assertEquals(215,s.getExitCode(DummyHostname1,HBASE_MASTER));
}
InternalCallVerifier EqualityVerifier (){
{
add(command);
add(command);
}
}
).anyTimes();
replay(am);
HeartBeatHandler handler=new HeartBeatHandler(fsm,aq,am,injector);
Register reg=new Register();
HostInfo hi=new HostInfo();
hi.setHostName(DummyHostname1);
hi.setOS(DummyOs);
hi.setOSRelease(DummyOSRelease);
reg.setHostname(DummyHostname1);
reg.setHardwareProfile(hi);
reg.setAgentVersion(metaInfo.getServerVersion());
handler.handleRegistration(reg);
hostObject.setState(HostState.UNHEALTHY);
aq.enqueue(DummyHostname1,new StatusCommand());
HeartBeat hb1=new HeartBeat();
hb1.setResponseId(0);
hb1.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb1.setHostname(DummyHostname1);
RecoveryReport rr=new RecoveryReport();
rr.setSummary("RECOVERABLE");
List compRecReports=new ArrayList();
ComponentRecoveryReport compRecReport=new ComponentRecoveryReport();
compRecReport.setLimitReached(Boolean.FALSE);
compRecReport.setName("DATANODE");
compRecReport.setNumAttempts(2);
compRecReports.add(compRecReport);
rr.setComponentReports(compRecReports);
hb1.setRecoveryReport(rr);
handler.handleHeartBeat(hb1);
assertEquals("RECOVERABLE",hostObject.getRecoveryReport().getSummary());
assertEquals(1,hostObject.getRecoveryReport().getComponentReports().size());
assertEquals(2,hostObject.getRecoveryReport().getComponentReports().get(0).getNumAttempts());
HeartBeat hb2=new HeartBeat();
hb2.setResponseId(1);
hb2.setNodeStatus(new HostStatus(Status.HEALTHY,DummyHostStatus));
hb2.setHostname(DummyHostname1);
rr=new RecoveryReport();
rr.setSummary("UNRECOVERABLE");
compRecReports=new ArrayList();
compRecReport=new ComponentRecoveryReport();
compRecReport.setLimitReached(Boolean.TRUE);
compRecReport.setName("DATANODE");
compRecReport.setNumAttempts(5);
compRecReports.add(compRecReport);
rr.setComponentReports(compRecReports);
hb2.setRecoveryReport(rr);
handler.handleHeartBeat(hb2);
assertEquals("UNRECOVERABLE",hostObject.getRecoveryReport().getSummary());
assertEquals(1,hostObject.getRecoveryReport().getComponentReports().size());
assertEquals(5,hostObject.getRecoveryReport().getComponentReports().get(0).getNumAttempts());
}
InternalCallVerifier EqualityVerifier ());
replay(am);
Clusters fsm=clusters;
fsm.addHost(DummyHostname1);
Host hostObject=clusters.getHost(DummyHostname1);
hostObject.setIPv4("ipv4");
hostObject.setIPv6("ipv6");
hostObject.setOsType(DummyOsType);
ActionQueue aq=new ActionQueue();
HeartBeatHandler handler=new HeartBeatHandler(fsm,aq,am,injector);
Register reg=new Register();
HostInfo hi=new HostInfo();
hi.setHostName(DummyHostname1);
hi.setOS(DummyOs);
hi.setOSRelease(DummyOSRelease);
reg.setHostname(DummyHostname1);
reg.setHardwareProfile(hi);
reg.setAgentVersion(metaInfo.getServerVersion());
handler.handleRegistration(reg);
hostObject.setState(HostState.UNHEALTHY);
ExecutionCommand execCmd=new ExecutionCommand();
execCmd.setRequestAndStage(2,34);
execCmd.setHostname(DummyHostname1);
aq.enqueue(DummyHostname1,new ExecutionCommand());
HeartBeat hb=new HeartBeat();
hb.setResponseId(0);
HostStatus hs=new HostStatus(Status.HEALTHY,DummyHostStatus);
List al=new ArrayList();
al.add(new Alert());
hb.setNodeStatus(hs);
hb.setHostname(DummyHostname1);
handler.handleHeartBeat(hb);
assertEquals(HostState.HEALTHY,hostObject.getState());
assertEquals(0,aq.dequeueAll(DummyHostname1).size());
}
InternalCallVerifier BooleanVerifier dummyCmds=new ArrayList();
StatusCommand statusCmd1=new StatusCommand();
statusCmd1.setClusterName(DummyCluster);
statusCmd1.setServiceName(HDFS);
dummyCmds.add(statusCmd1);
HeartbeatMonitor hm=mock(HeartbeatMonitor.class);
when(hm.generateStatusCommands(anyString())).thenReturn(dummyCmds);
ActionManager am=getMockActionManager();
replay(am);
Clusters fsm=clusters;
ActionQueue actionQueue=new ActionQueue();
HeartBeatHandler handler=new HeartBeatHandler(fsm,actionQueue,am,injector);
handler.setHeartbeatMonitor(hm);
clusters.addHost(DummyHostname1);
Host hostObject=clusters.getHost(DummyHostname1);
hostObject.setIPv4("ipv4");
hostObject.setIPv6("ipv6");
Register reg=new Register();
HostInfo hi=new HostInfo();
hi.setHostName(DummyHostname1);
hi.setOS(DummyOsType);
reg.setHostname(DummyHostname1);
reg.setHardwareProfile(hi);
reg.setAgentVersion(metaInfo.getServerVersion());
RegistrationResponse registrationResponse=handler.handleRegistration(reg);
registrationResponse.getStatusCommands();
assertTrue(registrationResponse.getStatusCommands().size() == 1);
assertTrue(registrationResponse.getStatusCommands().get(0).equals(statusCmd1));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setServiceName(HDFS);
cr.setTaskId(1);
cr.setRole(DATANODE);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setRoleCommand("START");
cr.setClusterName(DummyCluster);
cr.setConfigurationTags(new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
);
reports.add(cr);
hb.setReports(reports);
HostEntity host1=hostDAO.findByName(DummyHostname1);
Assert.assertNotNull(host1);
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
Assert.assertNotNull(serviceComponentHost1.getActualConfigs());
Assert.assertEquals(serviceComponentHost1.getActualConfigs().size(),1);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setServiceName(HDFS);
cr.setRoleCommand("INSTALL");
cr.setCustomCommand("EXECUTION_COMMAND");
cr.setTaskId(1);
cr.setRole(HDFS_CLIENT);
cr.setStatus("COMPLETED");
cr.setStdErr("");
cr.setStdOut("");
cr.setExitCode(215);
cr.setClusterName(DummyCluster);
cr.setConfigurationTags(new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
);
reports.add(cr);
hb.setReports(reports);
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
add(command);
}
}
);
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
Assert.assertNotNull(serviceComponentHost.getActualConfigs());
Assert.assertFalse(serviceComponentHost.isRestartRequired());
Assert.assertEquals(serviceComponentHost.getActualConfigs().size(),1);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier reports=new ArrayList();
CommandReport cr=new CommandReport();
cr.setActionId(StageUtils.getActionId(requestId,stageId));
cr.setTaskId(1);
cr.setClusterName(DummyCluster);
cr.setServiceName(HDFS);
cr.setRole(DATANODE);
cr.setRoleCommand("INSTALL");
cr.setStatus(HostRoleStatus.IN_PROGRESS.toString());
cr.setStdErr("none");
cr.setStdOut("dummy output");
cr.setExitCode(777);
reports.add(cr);
hb.setReports(reports);
hb.setComponentStatus(new ArrayList());
final HostRoleCommand command=hostRoleCommandFactory.create(DummyHostname1,Role.DATANODE,null,null);
ActionManager am=getMockActionManager();
expect(am.getTasks(anyObject(List.class))).andReturn(new ArrayList(){
{
add(command);
}
}
).anyTimes();
replay(am);
HeartBeatHandler handler=getHeartBeatHandler(am,aq);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.UPGRADING,State.UPGRADING,serviceComponentHost1.getState());
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(1);
cr.setStatus(HostRoleStatus.COMPLETED.toString());
cr.setExitCode(0);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.INSTALLED,State.INSTALLED,serviceComponentHost1.getState());
serviceComponentHost1.setState(State.UPGRADING);
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(2);
cr.setStatus(HostRoleStatus.FAILED.toString());
cr.setExitCode(3);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.UPGRADING,State.UPGRADING,serviceComponentHost1.getState());
serviceComponentHost1.setState(State.UPGRADING);
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(3);
cr.setStatus(HostRoleStatus.PENDING.toString());
cr.setExitCode(55);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.UPGRADING,State.UPGRADING,serviceComponentHost1.getState());
serviceComponentHost1.setState(State.UPGRADING);
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(4);
cr.setStatus(HostRoleStatus.QUEUED.toString());
cr.setExitCode(55);
handler.handleHeartBeat(hb);
assertEquals("Host state should be " + State.UPGRADING,State.UPGRADING,serviceComponentHost1.getState());
}
Class: org.apache.ambari.server.agent.TestHeartbeatMonitor InternalCallVerifier EqualityVerifier IterativeVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hostNames=new HashSet(){
{
add(hostname1);
}
}
;
clusters.mapHostsToCluster(hostNames,clusterName);
Service hdfs=cluster.addService(serviceName);
hdfs.persist();
hdfs.addServiceComponent(Role.DATANODE.name()).persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.SECONDARY_NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.getServiceComponent(Role.DATANODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.NAMENODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
ActionQueue aqMock=mock(ActionQueue.class);
ArgumentCaptor commandCaptor=ArgumentCaptor.forClass(AgentCommand.class);
ActionManager am=mock(ActionManager.class);
HeartbeatMonitor hm=new HeartbeatMonitor(clusters,aqMock,am,heartbeatMonitorWakeupIntervalMS,injector);
HeartBeatHandler handler=new HeartBeatHandler(clusters,aqMock,am,injector);
Register reg=new Register();
reg.setHostname(hostname1);
reg.setResponseId(12);
reg.setTimestamp(System.currentTimeMillis() - 15);
reg.setAgentVersion(ambariMetaInfo.getServerVersion());
HostInfo hi=new HostInfo();
hi.setOS("Centos5");
reg.setHardwareProfile(hi);
handler.handleRegistration(reg);
HeartBeat hb=new HeartBeat();
hb.setHostname(hostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY,"cool"));
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(13);
handler.handleHeartBeat(hb);
LOG.info("YYY");
clusters.getHost(hostname1).setLastHeartbeatTime(System.currentTimeMillis() - 15);
hm.start();
Thread.sleep(3 * heartbeatMonitorWakeupIntervalMS);
hm.shutdown();
int tryNumber=0;
while (hm.isAlive()) {
hm.join(2 * heartbeatMonitorWakeupIntervalMS);
tryNumber++;
if (tryNumber >= 5) {
fail("HeartbeatMonitor should be already stopped");
}
}
verify(aqMock,atLeast(2)).enqueue(eq(hostname1),commandCaptor.capture());
List cmds=commandCaptor.getAllValues();
assertTrue("HeartbeatMonitor should generate StatusCommands for host1",cmds.size() >= 2);
for ( AgentCommand command : cmds) {
assertEquals("HDFS",((StatusCommand)command).getServiceName());
}
}
BranchVerifier InternalCallVerifier EqualityVerifier hostNames=new HashSet(){
{
add(hostname1);
}
}
;
clusters.mapHostsToCluster(hostNames,clusterName);
Service hdfs=cluster.addService(serviceName);
hdfs.persist();
hdfs.addServiceComponent(Role.DATANODE.name()).persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.SECONDARY_NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.HDFS_CLIENT.name()).persist();
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).addServiceComponentHost(hostname1);
ActionQueue aq=new ActionQueue();
ActionManager am=mock(ActionManager.class);
HeartbeatMonitor hm=new HeartbeatMonitor(clusters,aq,am,10,injector);
HeartBeatHandler handler=new HeartBeatHandler(clusters,aq,am,injector);
Register reg=new Register();
reg.setHostname(hostname1);
reg.setResponseId(12);
reg.setTimestamp(System.currentTimeMillis() - 300);
reg.setAgentVersion(ambariMetaInfo.getServerVersion());
HostInfo hi=new HostInfo();
hi.setOS("Centos5");
reg.setHardwareProfile(hi);
handler.handleRegistration(reg);
cluster=clusters.getClustersForHost(hostname1).iterator().next();
for ( ServiceComponentHost sch : cluster.getServiceComponentHosts(hostname1)) {
if (sch.getServiceComponentName().equals("NAMENODE")) {
sch.handleEvent(new ServiceComponentHostInstallEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis(),"HDP-0.1"));
sch.handleEvent(new ServiceComponentHostOpSucceededEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis()));
sch.handleEvent(new ServiceComponentHostStartedEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis()));
}
else if (sch.getServiceComponentName().equals("DATANODE")) {
sch.handleEvent(new ServiceComponentHostInstallEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis(),"HDP-0.1"));
}
else if (sch.getServiceComponentName().equals("SECONDARY_NAMENODE")) {
sch.handleEvent(new ServiceComponentHostInstallEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis(),"HDP-0.1"));
sch.handleEvent(new ServiceComponentHostOpSucceededEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis()));
sch.handleEvent(new ServiceComponentHostDisableEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis()));
}
}
HeartBeat hb=new HeartBeat();
hb.setHostname(hostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY,"cool"));
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(12);
handler.handleHeartBeat(hb);
hm.start();
aq.enqueue(hostname1,new ExecutionCommand());
while (aq.size(hostname1) != 0) {
Thread.sleep(1);
}
hm.shutdown();
cluster=clusters.getClustersForHost(hostname1).iterator().next();
for ( ServiceComponentHost sch : cluster.getServiceComponentHosts(hostname1)) {
Service s=cluster.getService(sch.getServiceName());
ServiceComponent sc=s.getServiceComponent(sch.getServiceComponentName());
if (sch.getServiceComponentName().equals("NAMENODE")) {
assertEquals(sch.getServiceComponentName(),State.UNKNOWN,sch.getState());
}
else if (sch.getServiceComponentName().equals("DATANODE")) {
assertEquals(sch.getServiceComponentName(),State.INSTALLING,sch.getState());
}
else if (sc.isClientComponent()) {
assertEquals(sch.getServiceComponentName(),State.INIT,sch.getState());
}
else if (sch.getServiceComponentName().equals("SECONDARY_NAMENODE")) {
assertEquals(sch.getServiceComponentName(),State.DISABLED,sch.getState());
}
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hostNames=new HashSet(){
{
add(hostname1);
add(hostname2);
}
}
;
ConfigFactory configFactory=injector.getInstance(ConfigFactory.class);
Config config=configFactory.createNew(cluster,"hadoop-env",new HashMap(){
{
put("a","b");
}
}
,new HashMap>());
config.setTag("version1");
cluster.addConfig(config);
cluster.addDesiredConfig("_test",Collections.singleton(config));
clusters.mapHostsToCluster(hostNames,clusterName);
Service hdfs=cluster.addService(serviceName);
hdfs.persist();
hdfs.addServiceComponent(Role.DATANODE.name()).persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.SECONDARY_NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.getServiceComponent(Role.DATANODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.NAMENODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
ActionQueue aq=new ActionQueue();
ActionManager am=mock(ActionManager.class);
HeartbeatMonitor hm=new HeartbeatMonitor(clusters,aq,am,heartbeatMonitorWakeupIntervalMS,injector);
HeartBeatHandler handler=new HeartBeatHandler(clusters,aq,am,injector);
Register reg=new Register();
reg.setHostname(hostname1);
reg.setResponseId(12);
reg.setTimestamp(System.currentTimeMillis() - 300);
reg.setAgentVersion(ambariMetaInfo.getServerVersion());
HostInfo hi=new HostInfo();
hi.setOS("Centos5");
reg.setHardwareProfile(hi);
handler.handleRegistration(reg);
HeartBeat hb=new HeartBeat();
hb.setHostname(hostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY,"cool"));
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(12);
handler.handleHeartBeat(hb);
List cmds=hm.generateStatusCommands(hostname1);
assertTrue("HeartbeatMonitor should generate StatusCommands for host1",cmds.size() == 3);
assertEquals("HDFS",cmds.get(0).getServiceName());
boolean containsDATANODEStatus=false;
boolean containsNAMENODEStatus=false;
boolean containsSECONDARY_NAMENODEStatus=false;
for ( StatusCommand cmd : cmds) {
containsDATANODEStatus|=cmd.getComponentName().equals("DATANODE");
containsNAMENODEStatus|=cmd.getComponentName().equals("NAMENODE");
containsSECONDARY_NAMENODEStatus|=cmd.getComponentName().equals("SECONDARY_NAMENODE");
assertTrue(cmd.getConfigurations().size() > 0);
}
assertEquals(true,containsDATANODEStatus);
assertEquals(true,containsNAMENODEStatus);
assertEquals(true,containsSECONDARY_NAMENODEStatus);
cmds=hm.generateStatusCommands(hostname2);
assertTrue("HeartbeatMonitor should not generate StatusCommands for host2 because it has no services",cmds.isEmpty());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hostNames=new HashSet(){
{
add(hostname1);
add(hostname2);
}
}
;
ConfigFactory configFactory=injector.getInstance(ConfigFactory.class);
Config config=configFactory.createNew(cluster,"hadoop-env",new HashMap(){
{
put("a","b");
}
}
,new HashMap>());
config.setTag("version1");
cluster.addConfig(config);
cluster.addDesiredConfig("_test",Collections.singleton(config));
clusters.mapHostsToCluster(hostNames,clusterName);
Service hdfs=cluster.addService(serviceName);
hdfs.persist();
hdfs.addServiceComponent(Role.DATANODE.name()).persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.SECONDARY_NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.HDFS_CLIENT.name()).persist();
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).addServiceComponentHost(hostname1).persist();
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).addServiceComponentHost(hostname2).persist();
hdfs.getServiceComponent(Role.DATANODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.NAMENODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).getServiceComponentHost(hostname2).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.DATANODE.name()).getServiceComponentHost(hostname1).setDesiredState(State.INSTALLED);
hdfs.getServiceComponent(Role.NAMENODE.name()).getServiceComponentHost(hostname1).setDesiredState(State.INSTALLED);
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).getServiceComponentHost(hostname1).setDesiredState(State.INSTALLED);
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).getServiceComponentHost(hostname1).setDesiredState(State.INSTALLED);
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).getServiceComponentHost(hostname2).setDesiredState(State.INSTALLED);
ActionQueue aq=new ActionQueue();
ActionManager am=mock(ActionManager.class);
HeartbeatMonitor hm=new HeartbeatMonitor(clusters,aq,am,heartbeatMonitorWakeupIntervalMS,injector);
HeartBeatHandler handler=new HeartBeatHandler(clusters,aq,am,injector);
Register reg=new Register();
reg.setHostname(hostname1);
reg.setResponseId(12);
reg.setTimestamp(System.currentTimeMillis() - 300);
reg.setAgentVersion(ambariMetaInfo.getServerVersion());
HostInfo hi=new HostInfo();
hi.setOS("Centos5");
reg.setHardwareProfile(hi);
handler.handleRegistration(reg);
HeartBeat hb=new HeartBeat();
hb.setHostname(hostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY,"cool"));
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(12);
handler.handleHeartBeat(hb);
List cmds=hm.generateStatusCommands(hostname1);
assertTrue("HeartbeatMonitor should generate StatusCommands for host1",cmds.size() == 4);
assertEquals("HDFS",cmds.get(0).getServiceName());
boolean containsDATANODEStatus=false;
boolean containsNAMENODEStatus=false;
boolean containsSECONDARY_NAMENODEStatus=false;
boolean containsHDFS_CLIENTStatus=false;
for ( StatusCommand cmd : cmds) {
containsDATANODEStatus|=cmd.getComponentName().equals("DATANODE");
containsNAMENODEStatus|=cmd.getComponentName().equals("NAMENODE");
containsSECONDARY_NAMENODEStatus|=cmd.getComponentName().equals("SECONDARY_NAMENODE");
containsHDFS_CLIENTStatus|=cmd.getComponentName().equals("HDFS_CLIENT");
assertTrue(cmd.getConfigurations().size() > 0);
assertEquals(State.INSTALLED,cmd.getDesiredState());
assertEquals(false,cmd.getHasStaleConfigs());
}
assertTrue(containsDATANODEStatus);
assertTrue(containsNAMENODEStatus);
assertTrue(containsSECONDARY_NAMENODEStatus);
assertTrue(containsHDFS_CLIENTStatus);
cmds=hm.generateStatusCommands(hostname2);
assertTrue("HeartbeatMonitor should generate StatusCommands for host2, " + "even if it has only client components",cmds.size() == 1);
assertTrue(cmds.get(0).getComponentName().equals(Role.HDFS_CLIENT.name()));
assertEquals(hostname2,cmds.get(0).getHostname());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hostNames=new HashSet(){
{
add(hostname1);
add(hostname2);
}
}
;
clusters.mapHostsToCluster(hostNames,clusterName);
Service hdfs=cluster.addService(serviceName);
hdfs.persist();
hdfs.addServiceComponent(Role.DATANODE.name()).persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.addServiceComponent(Role.SECONDARY_NAMENODE.name()).persist();
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).addServiceComponentHost(hostname1).persist();
hdfs.getServiceComponent(Role.DATANODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.NAMENODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
hdfs.getServiceComponent(Role.SECONDARY_NAMENODE.name()).getServiceComponentHost(hostname1).setState(State.INSTALLED);
ActionQueue aq=new ActionQueue();
ActionManager am=mock(ActionManager.class);
HeartbeatMonitor hm=new HeartbeatMonitor(clusters,aq,am,heartbeatMonitorWakeupIntervalMS,injector);
HeartBeatHandler handler=new HeartBeatHandler(clusters,aq,am,injector);
Register reg=new Register();
reg.setHostname(hostname1);
reg.setResponseId(12);
reg.setTimestamp(System.currentTimeMillis() - 300);
reg.setAgentVersion(ambariMetaInfo.getServerVersion());
HostInfo hi=new HostInfo();
hi.setOS("Centos5");
reg.setHardwareProfile(hi);
handler.handleRegistration(reg);
HeartBeat hb=new HeartBeat();
hb.setHostname(hostname1);
hb.setNodeStatus(new HostStatus(HostStatus.Status.HEALTHY,"cool"));
hb.setTimestamp(System.currentTimeMillis());
hb.setResponseId(12);
handler.handleHeartBeat(hb);
List cmds=hm.generateStatusCommands(hostname1);
assertEquals("HeartbeatMonitor should generate StatusCommands for host1",3,cmds.size());
assertEquals("HDFS",cmds.get(0).getServiceName());
cmds=hm.generateStatusCommands(hostname2);
assertTrue("HeartbeatMonitor should not generate StatusCommands for host2 because it has no services",cmds.isEmpty());
}
Class: org.apache.ambari.server.alerts.AgentHeartbeatAlertRunnableTest APIUtilityVerifier InternalCallVerifier EqualityVerifier events=m_listener.getAlertEventInstances(AlertReceivedEvent.class);
assertEquals(1,events.size());
AlertReceivedEvent event=(AlertReceivedEvent)events.get(0);
Alert alert=event.getAlert();
assertEquals("AMBARI",alert.getService());
assertEquals("AMBARI_SERVER",alert.getComponent());
assertEquals(AlertState.OK,alert.getState());
assertEquals(DEFINITION_NAME,alert.getName());
verify(m_definition,m_host,m_cluster,m_clusters,m_definitionDao);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier events=m_listener.getAlertEventInstances(AlertReceivedEvent.class);
assertEquals(1,events.size());
AlertReceivedEvent event=(AlertReceivedEvent)events.get(0);
Alert alert=event.getAlert();
assertEquals("AMBARI",alert.getService());
assertEquals("AMBARI_SERVER",alert.getComponent());
assertEquals(AlertState.CRITICAL,alert.getState());
assertEquals(DEFINITION_NAME,alert.getName());
verify(m_definition,m_host,m_cluster,m_clusters,m_definitionDao);
}
Class: org.apache.ambari.server.alerts.StaleAlertRunnableTest APIUtilityVerifier InternalCallVerifier EqualityVerifier events=m_listener.getAlertEventInstances(AlertReceivedEvent.class);
assertEquals(1,events.size());
AlertReceivedEvent event=(AlertReceivedEvent)events.get(0);
Alert alert=event.getAlert();
assertEquals("AMBARI",alert.getService());
assertEquals("AMBARI_SERVER",alert.getComponent());
assertEquals(AlertState.OK,alert.getState());
assertEquals(DEFINITION_NAME,alert.getName());
verify(m_cluster,m_clusters,m_definitionDao);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier events=m_listener.getAlertEventInstances(AlertReceivedEvent.class);
assertEquals(1,events.size());
AlertReceivedEvent event=(AlertReceivedEvent)events.get(0);
Alert alert=event.getAlert();
assertEquals("AMBARI",alert.getService());
assertEquals("AMBARI_SERVER",alert.getComponent());
assertEquals(AlertState.OK,alert.getState());
assertEquals(DEFINITION_NAME,alert.getName());
verify(m_cluster,m_clusters,m_definitionDao);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier events=m_listener.getAlertEventInstances(AlertReceivedEvent.class);
assertEquals(1,events.size());
AlertReceivedEvent event=(AlertReceivedEvent)events.get(0);
Alert alert=event.getAlert();
assertEquals("AMBARI",alert.getService());
assertEquals("AMBARI_SERVER",alert.getComponent());
assertEquals(AlertState.CRITICAL,alert.getState());
assertEquals(DEFINITION_NAME,alert.getName());
verify(m_cluster,m_clusters,m_definitionDao);
}
Class: org.apache.ambari.server.api.AmbariCsrfProtectionFilterTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.api.AmbariErrorHandlerTest UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.api.handlers.CreateHandlerTest InternalCallVerifier EqualityVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier setResources=new HashSet();
setResources.add(resource1);
setResources.add(resource2);
expect(request.getResource()).andReturn(resource).atLeastOnce();
expect(request.getQueryPredicate()).andReturn(null).atLeastOnce();
expect(request.getRenderer()).andReturn(renderer);
expect(request.getBody()).andReturn(body).atLeastOnce();
expect(resource.getQuery()).andReturn(query);
query.setRenderer(renderer);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.isCreatable()).andReturn(true).anyTimes();
expect(pm.create(resource,body)).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Complete);
expect(status.getAssociatedResources()).andReturn(setResources);
expect(resource1.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(resource2.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(request,body,resource,resourceDefinition,query,pm,status,resource1,resource2);
Result result=new TestCreateHandler(pm).handleRequest(request);
assertNotNull(result);
TreeNode tree=result.getResultTree();
assertEquals(1,tree.getChildren().size());
TreeNode resourcesNode=tree.getChild("resources");
assertEquals(2,resourcesNode.getChildren().size());
boolean foundResource1=false;
boolean foundResource2=false;
for ( TreeNode child : resourcesNode.getChildren()) {
Resource r=child.getObject();
if (r == resource1 && !foundResource1) {
foundResource1=true;
}
else if (r == resource2 && !foundResource2) {
foundResource2=true;
}
else {
fail();
}
}
assertEquals(ResultStatus.STATUS.CREATED,result.getStatus().getStatus());
verify(request,body,resource,resourceDefinition,query,pm,status,resource1,resource2);
}
BranchVerifier UtilityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier setResources=new HashSet();
setResources.add(resource1);
setResources.add(resource2);
expect(request.getResource()).andReturn(resource).atLeastOnce();
expect(request.getBody()).andReturn(body).atLeastOnce();
expect(request.getQueryPredicate()).andReturn(null).atLeastOnce();
expect(request.getRenderer()).andReturn(renderer);
expect(resource.getQuery()).andReturn(query);
query.setRenderer(renderer);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.isCreatable()).andReturn(true).anyTimes();
expect(pm.create(resource,body)).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Accepted);
expect(status.getAssociatedResources()).andReturn(setResources);
expect(resource1.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(resource2.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(status.getRequestResource()).andReturn(requestResource).anyTimes();
replay(request,body,resource,resourceDefinition,query,pm,status,resource1,resource2,requestResource);
Result result=new TestCreateHandler(pm).handleRequest(request);
assertNotNull(result);
TreeNode tree=result.getResultTree();
assertEquals(2,tree.getChildren().size());
TreeNode resourcesNode=tree.getChild("resources");
assertEquals(2,resourcesNode.getChildren().size());
boolean foundResource1=false;
boolean foundResource2=false;
for ( TreeNode child : resourcesNode.getChildren()) {
Resource r=child.getObject();
if (r == resource1 && !foundResource1) {
foundResource1=true;
}
else if (r == resource2 && !foundResource2) {
foundResource2=true;
}
else {
fail();
}
}
TreeNode statusNode=tree.getChild("request");
assertNotNull(statusNode);
assertEquals(0,statusNode.getChildren().size());
assertSame(requestResource,statusNode.getObject());
assertEquals(ResultStatus.STATUS.ACCEPTED,result.getStatus().getStatus());
verify(request,body,resource,resourceDefinition,query,pm,status,resource1,resource2,requestResource);
}
BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier setResources=new HashSet();
setResources.add(resource1);
setResources.add(resource2);
expect(request.getResource()).andReturn(resource).atLeastOnce();
expect(request.getQueryPredicate()).andReturn(null).atLeastOnce();
expect(request.getRenderer()).andReturn(renderer);
expect(request.getBody()).andReturn(body);
expect(resource.getQuery()).andReturn(query);
query.setRenderer(renderer);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.isCreatable()).andReturn(true).anyTimes();
expect(pm.create(resource,body)).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Complete);
expect(status.getAssociatedResources()).andReturn(setResources);
expect(resource1.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(resource2.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(request,body,resource,resourceDefinition,query,pm,status,resource1,resource2);
Result result=new TestCreateHandler(pm).handleRequest(request);
assertNotNull(result);
TreeNode tree=result.getResultTree();
assertEquals(1,tree.getChildren().size());
TreeNode resourcesNode=tree.getChild("resources");
assertEquals(2,resourcesNode.getChildren().size());
boolean foundResource1=false;
boolean foundResource2=false;
for ( TreeNode child : resourcesNode.getChildren()) {
Resource r=child.getObject();
if (r == resource1 && !foundResource1) {
foundResource1=true;
}
else if (r == resource2 && !foundResource2) {
foundResource2=true;
}
else {
fail();
}
}
assertEquals(ResultStatus.STATUS.CREATED,result.getStatus().getStatus());
verify(request,body,resource,resourceDefinition,query,pm,status,resource1,resource2);
}
Class: org.apache.ambari.server.api.handlers.DeleteHandlerTest BranchVerifier UtilityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier setResources=new HashSet();
setResources.add(resource1);
setResources.add(resource2);
expect(request.getResource()).andReturn(resource).anyTimes();
expect(request.getBody()).andReturn(body).atLeastOnce();
expect(request.getQueryPredicate()).andReturn(null).atLeastOnce();
expect(resource.getQuery()).andReturn(query).atLeastOnce();
expect(request.getRenderer()).andReturn(renderer);
query.setRenderer(renderer);
expect(pm.delete(resource,body)).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Accepted);
expect(status.getAssociatedResources()).andReturn(setResources);
expect(resource1.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(resource2.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(status.getRequestResource()).andReturn(requestResource).anyTimes();
replay(request,body,resource,pm,status,resource1,resource2,requestResource,query);
Result result=new TestDeleteHandler(pm).handleRequest(request);
assertNotNull(result);
TreeNode tree=result.getResultTree();
assertEquals(2,tree.getChildren().size());
TreeNode resourcesNode=tree.getChild("resources");
assertEquals(2,resourcesNode.getChildren().size());
boolean foundResource1=false;
boolean foundResource2=false;
for ( TreeNode child : resourcesNode.getChildren()) {
Resource r=child.getObject();
if (r == resource1 && !foundResource1) {
foundResource1=true;
}
else if (r == resource2 && !foundResource2) {
foundResource2=true;
}
else {
fail();
}
}
TreeNode statusNode=tree.getChild("request");
assertNotNull(statusNode);
assertEquals(0,statusNode.getChildren().size());
assertSame(requestResource,statusNode.getObject());
assertEquals(ResultStatus.STATUS.ACCEPTED,result.getStatus().getStatus());
verify(request,body,resource,pm,status,resource1,resource2,requestResource,query);
}
BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier setResources=new HashSet();
setResources.add(resource1);
setResources.add(resource2);
expect(request.getResource()).andReturn(resource).atLeastOnce();
expect(request.getBody()).andReturn(body).atLeastOnce();
expect(request.getQueryPredicate()).andReturn(userPredicate).atLeastOnce();
expect(resource.getQuery()).andReturn(query).atLeastOnce();
expect(request.getRenderer()).andReturn(renderer);
query.setRenderer(renderer);
query.setUserPredicate(userPredicate);
expect(pm.delete(resource,body)).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Complete);
expect(status.getAssociatedResources()).andReturn(setResources);
expect(resource1.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(resource2.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(request,body,resource,pm,status,resource1,resource2,userPredicate,query);
Result result=new TestDeleteHandler(pm).handleRequest(request);
assertNotNull(result);
TreeNode tree=result.getResultTree();
assertEquals(1,tree.getChildren().size());
TreeNode resourcesNode=tree.getChild("resources");
assertEquals(2,resourcesNode.getChildren().size());
boolean foundResource1=false;
boolean foundResource2=false;
for ( TreeNode child : resourcesNode.getChildren()) {
Resource r=child.getObject();
if (r == resource1 && !foundResource1) {
foundResource1=true;
}
else if (r == resource2 && !foundResource2) {
foundResource2=true;
}
else {
fail();
}
}
assertEquals(ResultStatus.STATUS.OK,result.getStatus().getStatus());
verify(request,body,resource,pm,status,resource1,resource2,userPredicate,query);
}
InternalCallVerifier EqualityVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier setResources=new HashSet();
setResources.add(resource1);
setResources.add(resource2);
expect(request.getResource()).andReturn(resource).atLeastOnce();
expect(request.getBody()).andReturn(body).atLeastOnce();
expect(request.getQueryPredicate()).andReturn(userPredicate).atLeastOnce();
expect(resource.getQuery()).andReturn(query).atLeastOnce();
expect(request.getRenderer()).andReturn(renderer);
query.setRenderer(renderer);
query.setUserPredicate(userPredicate);
expect(pm.delete(resource,body)).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Complete);
expect(status.getAssociatedResources()).andReturn(setResources);
expect(resource1.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(resource2.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(request,body,resource,pm,status,resource1,resource2,userPredicate,query);
Result result=new TestDeleteHandler(pm).handleRequest(request);
assertNotNull(result);
TreeNode tree=result.getResultTree();
assertEquals(1,tree.getChildren().size());
TreeNode resourcesNode=tree.getChild("resources");
assertEquals(2,resourcesNode.getChildren().size());
boolean foundResource1=false;
boolean foundResource2=false;
for ( TreeNode child : resourcesNode.getChildren()) {
Resource r=child.getObject();
if (r == resource1 && !foundResource1) {
foundResource1=true;
}
else if (r == resource2 && !foundResource2) {
foundResource2=true;
}
else {
fail();
}
}
assertEquals(ResultStatus.STATUS.OK,result.getStatus().getStatus());
verify(request,body,resource,pm,status,resource1,resource2,userPredicate,query);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.api.handlers.QueryCreateHandlerTest InternalCallVerifier EqualityVerifier mapIds=new HashMap();
Set setRequestProps=new HashSet();
Map mapProperties=new HashMap();
Set> arraySet=new HashSet>();
mapProperties.put("components",arraySet);
Map map=new HashMap();
map.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"SECONDARY_NAMENODE");
arraySet.add(map);
map=new HashMap();
map.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"HDFS_CLIENT");
arraySet.add(map);
setRequestProps.add(new NamedPropertySet("",mapProperties));
Map mapSubResources=new HashMap();
mapSubResources.put("components",subResource);
TreeNode resultTree=new TreeNodeImpl(null,null,"result");
resultTree.addChild(resource1,"resource1");
resultTree.addChild(resource2,"resource2");
expect(readHandler.handleRequest(request)).andReturn(result).atLeastOnce();
expect(result.getStatus()).andReturn(resultStatus).atLeastOnce();
expect(resultStatus.isErrorState()).andReturn(false).atLeastOnce();
expect(body.getBody()).andReturn(BODY_STRING).atLeastOnce();
expect(request.getResource()).andReturn(resourceInstance).atLeastOnce();
expect(request.getBody()).andReturn(body).atLeastOnce();
expect(body.getNamedPropertySets()).andReturn(setRequestProps).atLeastOnce();
expect(resourceInstance.getResourceDefinition()).andReturn(resourceDefinition).atLeastOnce();
expect(resourceInstance.getKeyValueMap()).andReturn(mapIds).atLeastOnce();
expect(resourceInstance.getSubResources()).andReturn(mapSubResources).atLeastOnce();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Service).atLeastOnce();
expect(subResource.getResourceDefinition()).andReturn(subResourceDefinition).atLeastOnce();
expect(subResourceDefinition.getType()).andReturn(Resource.Type.Component).atLeastOnce();
expect(controller.getSchema(Resource.Type.Service)).andReturn(serviceSchema).atLeastOnce();
expect(controller.getSchema(Resource.Type.Component)).andReturn(componentSchema).atLeastOnce();
expect(serviceSchema.getKeyPropertyId(Resource.Type.Service)).andReturn(resourceKeyProperty).atLeastOnce();
expect(componentSchema.getKeyPropertyId(Resource.Type.Service)).andReturn(createKeyProperty).atLeastOnce();
expect(result.getResultTree()).andReturn(resultTree).atLeastOnce();
expect(resource1.getPropertyValue(resourceKeyProperty)).andReturn("id1").atLeastOnce();
expect(resource2.getPropertyValue(resourceKeyProperty)).andReturn("id2").atLeastOnce();
expect(resourceInstanceFactory.createResource(Resource.Type.Component,mapIds)).andReturn(createResource).atLeastOnce();
expect(pm.create(anyObject(ResourceInstance.class),anyObject(RequestBody.class))).andThrow(new AuthorizationException());
replay(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,resourceInstanceFactory,createResource,readHandler,resultStatus);
Result testResult=new TestQueryCreateHandler(resourceInstanceFactory,controller,pm,readHandler).handleRequest(request);
assertEquals(ResultStatus.STATUS.FORBIDDEN,testResult.getStatus().getStatus());
verify(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,resourceInstanceFactory,createResource,readHandler,resultStatus);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier bodyCapture=new Capture();
Map mapIds=new HashMap();
Set setRequestProps=new HashSet();
Map mapProperties=new HashMap();
Set> arraySet=new HashSet>();
mapProperties.put("components",arraySet);
Map map=new HashMap();
map.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"SECONDARY_NAMENODE");
arraySet.add(map);
map=new HashMap();
map.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"HDFS_CLIENT");
arraySet.add(map);
setRequestProps.add(new NamedPropertySet("",mapProperties));
Set> setCreateProps=new HashSet>();
Map map1=new HashMap();
map1.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"SECONDARY_NAMENODE");
map1.put(createKeyProperty,"id1");
setCreateProps.add(map1);
Map map2=new HashMap();
map2.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"SECONDARY_NAMENODE");
map2.put(createKeyProperty,"id2");
setCreateProps.add(map2);
Map map3=new HashMap();
map3.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"HDFS_CLIENT");
map3.put(createKeyProperty,"id1");
setCreateProps.add(map3);
Map map4=new HashMap();
map4.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"HDFS_CLIENT");
map4.put(createKeyProperty,"id2");
setCreateProps.add(map4);
Map mapSubResources=new HashMap();
mapSubResources.put("components",subResource);
TreeNode resultTree=new TreeNodeImpl(null,null,"result");
resultTree.addChild(resource1,"resource1");
resultTree.addChild(resource2,"resource2");
Set setStatusResources=new HashSet();
setStatusResources.add(statusResource1);
setStatusResources.add(statusResource2);
expect(readHandler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(false);
expect(result.getResultTree()).andReturn(resultTree);
expect(body.getBody()).andReturn(BODY_STRING).anyTimes();
expect(request.getResource()).andReturn(resourceInstance).anyTimes();
expect(request.getBody()).andReturn(body).anyTimes();
expect(body.getNamedPropertySets()).andReturn(setRequestProps).anyTimes();
expect(resourceInstance.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceInstance.getKeyValueMap()).andReturn(mapIds).anyTimes();
expect(resourceInstance.getSubResources()).andReturn(mapSubResources).anyTimes();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Service).anyTimes();
expect(resourceDefinition.isCreatable()).andReturn(true).anyTimes();
expect(subResource.getResourceDefinition()).andReturn(subResourceDefinition).anyTimes();
expect(subResourceDefinition.getType()).andReturn(Resource.Type.Component).anyTimes();
expect(controller.getSchema(Resource.Type.Service)).andReturn(serviceSchema).anyTimes();
expect(controller.getSchema(Resource.Type.Component)).andReturn(componentSchema).anyTimes();
expect(serviceSchema.getKeyPropertyId(Resource.Type.Service)).andReturn(resourceKeyProperty).anyTimes();
expect(componentSchema.getKeyPropertyId(Resource.Type.Service)).andReturn(createKeyProperty).anyTimes();
expect(result.getResultTree()).andReturn(resultTree).anyTimes();
expect(resource1.getPropertyValue(resourceKeyProperty)).andReturn("id1").anyTimes();
expect(resource2.getPropertyValue(resourceKeyProperty)).andReturn("id2").anyTimes();
expect(resourceInstanceFactory.createResource(Resource.Type.Component,mapIds)).andReturn(createResource).anyTimes();
expect(createResource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(pm.create(same(createResource),capture(bodyCapture))).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Complete).anyTimes();
expect(status.getAssociatedResources()).andReturn(setStatusResources).anyTimes();
expect(statusResource1.getType()).andReturn(Resource.Type.Component).anyTimes();
expect(statusResource2.getType()).andReturn(Resource.Type.Component).anyTimes();
replay(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,resourceInstanceFactory,createResource,status,statusResource1,statusResource2,readHandler,resultStatus);
Result testResult=new TestQueryCreateHandler(resourceInstanceFactory,controller,pm,readHandler).handleRequest(request);
Collection> children=testResult.getResultTree().getChild("resources").getChildren();
assertEquals(2,children.size());
boolean containsStatusResource1=false;
boolean containsStatusResource2=false;
for ( TreeNode child : children) {
Resource r=child.getObject();
if (r == statusResource1) {
containsStatusResource1=true;
}
else if (r == statusResource2) {
containsStatusResource2=true;
}
}
assertTrue(containsStatusResource1);
assertTrue(containsStatusResource2);
assertEquals(ResultStatus.STATUS.CREATED,testResult.getStatus().getStatus());
RequestBody createBody=bodyCapture.getValue();
assertEquals(BODY_STRING,createBody.getBody());
assertEquals(4,createBody.getPropertySets().size());
assertEquals(setCreateProps,createBody.getPropertySets());
verify(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,resourceInstanceFactory,createResource,status,statusResource1,statusResource2,readHandler,resultStatus);
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
Set setRequestProps=new HashSet();
Map mapProperties=new HashMap();
Set> arraySet=new HashSet>();
mapProperties.put("foo",arraySet);
Map map=new HashMap();
map.put("prop","val");
arraySet.add(map);
arraySet=new HashSet>();
mapProperties.put("bar",arraySet);
map=new HashMap();
map.put("prop","val");
arraySet.add(map);
setRequestProps.add(new NamedPropertySet("",mapProperties));
Map mapSubResources=new HashMap();
mapSubResources.put("foo",subResource1);
mapSubResources.put("bar",subResource2);
TreeNode resultTree=new TreeNodeImpl(null,null,"result");
resultTree.addChild(resource1,"resource1");
resultTree.addChild(resource2,"resource2");
expect(readHandler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(queryResultStatus).anyTimes();
expect(queryResultStatus.isErrorState()).andReturn(false);
expect(result.getResultTree()).andReturn(resultTree);
expect(request.getResource()).andReturn(resourceInstance).anyTimes();
expect(request.getBody()).andReturn(body).anyTimes();
expect(body.getNamedPropertySets()).andReturn(setRequestProps).anyTimes();
expect(resourceInstance.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceInstance.getKeyValueMap()).andReturn(mapIds).anyTimes();
expect(resourceInstance.getSubResources()).andReturn(mapSubResources).anyTimes();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Service).anyTimes();
expect(subResource1.getResourceDefinition()).andReturn(subResourceDefinition1).anyTimes();
expect(subResourceDefinition1.getType()).andReturn(Resource.Type.Component).anyTimes();
expect(subResource2.getResourceDefinition()).andReturn(subResourceDefinition2).anyTimes();
expect(subResourceDefinition2.getType()).andReturn(Resource.Type.HostComponent).anyTimes();
expect(controller.getSchema(Resource.Type.Service)).andReturn(serviceSchema).anyTimes();
expect(controller.getSchema(Resource.Type.Component)).andReturn(subResSchema1).anyTimes();
expect(controller.getSchema(Resource.Type.HostComponent)).andReturn(subResSchema2).anyTimes();
expect(serviceSchema.getKeyPropertyId(Resource.Type.Service)).andReturn(resourceKeyProperty).anyTimes();
expect(subResSchema1.getKeyPropertyId(Resource.Type.Service)).andReturn(createKeyProperty).anyTimes();
expect(subResSchema2.getKeyPropertyId(Resource.Type.Service)).andReturn(createKeyProperty).anyTimes();
expect(result.getResultTree()).andReturn(resultTree).anyTimes();
expect(resource1.getPropertyValue(resourceKeyProperty)).andReturn("id1").anyTimes();
expect(resource2.getPropertyValue(resourceKeyProperty)).andReturn("id2").anyTimes();
replay(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource1,subResource2,subResourceDefinition1,subResourceDefinition2,controller,serviceSchema,subResSchema1,subResSchema2,resource1,resource2,pm,resourceInstanceFactory,createResource,status,statusResource1,statusResource2,readHandler,queryResultStatus);
Result testResult=new TestQueryCreateHandler(resourceInstanceFactory,controller,pm,readHandler).handleRequest(request);
ResultStatus resultStatus=testResult.getStatus();
assertEquals(ResultStatus.STATUS.BAD_REQUEST,resultStatus.getStatus());
assertEquals("Invalid Request: Multiple sub-resource types may not be created in the same request.",resultStatus.getMessage());
verify(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource1,subResource2,subResourceDefinition1,subResourceDefinition2,controller,serviceSchema,subResSchema1,subResSchema2,resource1,resource2,pm,resourceInstanceFactory,createResource,status,statusResource1,statusResource2,readHandler,queryResultStatus);
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
Set setRequestProps=new HashSet();
Map mapProperties=new HashMap();
Set> arraySet=new HashSet>();
mapProperties.put("",arraySet);
Map map=new HashMap();
map.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"SECONDARY_NAMENODE");
arraySet.add(map);
map=new HashMap();
map.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"HDFS_CLIENT");
arraySet.add(map);
setRequestProps.add(new NamedPropertySet("",mapProperties));
TreeNode resultTree=new TreeNodeImpl(null,null,"result");
resultTree.addChild(resource1,"resource1");
resultTree.addChild(resource2,"resource2");
expect(readHandler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(queryResultStatus).anyTimes();
expect(queryResultStatus.isErrorState()).andReturn(false);
expect(result.getResultTree()).andReturn(resultTree);
expect(request.getResource()).andReturn(resourceInstance).anyTimes();
expect(request.getBody()).andReturn(body).anyTimes();
expect(body.getNamedPropertySets()).andReturn(setRequestProps).anyTimes();
expect(resourceInstance.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceInstance.getKeyValueMap()).andReturn(mapIds).anyTimes();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Service).anyTimes();
expect(controller.getSchema(Resource.Type.Service)).andReturn(serviceSchema).anyTimes();
expect(result.getResultTree()).andReturn(resultTree).anyTimes();
expect(resource1.getPropertyValue(resourceKeyProperty)).andReturn("id1").anyTimes();
expect(resource2.getPropertyValue(resourceKeyProperty)).andReturn("id2").anyTimes();
replay(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,createResource,status,statusResource1,statusResource2,readHandler,queryResultStatus);
Result testResult=new TestQueryCreateHandler(null,controller,pm,readHandler).handleRequest(request);
ResultStatus resultStatus=testResult.getStatus();
assertEquals(ResultStatus.STATUS.BAD_REQUEST,resultStatus.getStatus());
assertEquals("Invalid Request: A sub-resource name must be supplied.",resultStatus.getMessage());
verify(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,createResource,status,statusResource1,statusResource2,readHandler,queryResultStatus);
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
Set setRequestProps=new HashSet();
TreeNode resultTree=new TreeNodeImpl(null,null,"result");
resultTree.addChild(resource1,"resource1");
resultTree.addChild(resource2,"resource2");
expect(readHandler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(queryResultStatus).anyTimes();
expect(queryResultStatus.isErrorState()).andReturn(false);
expect(result.getResultTree()).andReturn(resultTree);
expect(request.getResource()).andReturn(resourceInstance).anyTimes();
expect(request.getBody()).andReturn(body).anyTimes();
expect(body.getNamedPropertySets()).andReturn(setRequestProps).anyTimes();
expect(resourceInstance.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceInstance.getKeyValueMap()).andReturn(mapIds).anyTimes();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Service).anyTimes();
expect(controller.getSchema(Resource.Type.Service)).andReturn(serviceSchema).anyTimes();
expect(result.getResultTree()).andReturn(resultTree).anyTimes();
expect(resource1.getPropertyValue(resourceKeyProperty)).andReturn("id1").anyTimes();
expect(resource2.getPropertyValue(resourceKeyProperty)).andReturn("id2").anyTimes();
replay(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,createResource,status,statusResource1,statusResource2,readHandler,queryResultStatus);
Result testResult=new TestQueryCreateHandler(null,controller,pm,readHandler).handleRequest(request);
ResultStatus resultStatus=testResult.getStatus();
assertEquals(ResultStatus.STATUS.BAD_REQUEST,resultStatus.getStatus());
assertEquals("Invalid Request: A minimum of one sub-resource must be specified for creation.",resultStatus.getMessage());
verify(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,createResource,status,statusResource1,statusResource2,readHandler,queryResultStatus);
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
Set setRequestProps=new HashSet();
Map mapProperties=new HashMap();
Set> arraySet=new HashSet>();
mapProperties.put("INVALID",arraySet);
Map map=new HashMap();
map.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"SECONDARY_NAMENODE");
arraySet.add(map);
map=new HashMap();
map.put(PropertyHelper.getPropertyId("ServiceComponentInfo","component_name"),"HDFS_CLIENT");
arraySet.add(map);
setRequestProps.add(new NamedPropertySet("",mapProperties));
Map mapSubResources=new HashMap();
mapSubResources.put("components",subResource);
TreeNode resultTree=new TreeNodeImpl(null,null,"result");
resultTree.addChild(resource1,"resource1");
resultTree.addChild(resource2,"resource2");
expect(readHandler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(queryResultStatus).anyTimes();
expect(queryResultStatus.isErrorState()).andReturn(false);
expect(result.getResultTree()).andReturn(resultTree);
expect(request.getResource()).andReturn(resourceInstance).anyTimes();
expect(request.getBody()).andReturn(body).anyTimes();
expect(body.getNamedPropertySets()).andReturn(setRequestProps).anyTimes();
expect(resourceInstance.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceInstance.getKeyValueMap()).andReturn(mapIds).anyTimes();
expect(resourceInstance.getSubResources()).andReturn(mapSubResources).anyTimes();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Service).anyTimes();
expect(controller.getSchema(Resource.Type.Service)).andReturn(serviceSchema).anyTimes();
expect(result.getResultTree()).andReturn(resultTree).anyTimes();
expect(resource1.getPropertyValue(resourceKeyProperty)).andReturn("id1").anyTimes();
expect(resource2.getPropertyValue(resourceKeyProperty)).andReturn("id2").anyTimes();
replay(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,createResource,status,statusResource1,statusResource2,readHandler,queryResultStatus);
Result testResult=new TestQueryCreateHandler(null,controller,pm,readHandler).handleRequest(request);
ResultStatus resultStatus=testResult.getStatus();
assertEquals(ResultStatus.STATUS.BAD_REQUEST,resultStatus.getStatus());
assertEquals("Invalid Request: The specified sub-resource name is not valid: 'INVALID'.",resultStatus.getMessage());
verify(request,body,resourceInstance,resourceDefinition,query,predicate,result,subResource,subResourceDefinition,controller,serviceSchema,componentSchema,resource1,resource2,pm,createResource,status,statusResource1,statusResource2,readHandler,queryResultStatus);
}
Class: org.apache.ambari.server.api.handlers.ReadHandlerTest InternalCallVerifier EqualityVerifier emptyMap());
expect(request.getQueryPredicate()).andReturn(predicate);
query.setUserPredicate(predicate);
query.setPageRequest(null);
query.setSortRequest(null);
query.setRenderer(renderer);
SystemException systemException=new SystemException("testMsg",new RuntimeException());
expect(query.execute()).andThrow(systemException);
replay(request,resource,query,predicate);
ReadHandler handler=new ReadHandler();
Result result=handler.handleRequest(request);
assertEquals(ResultStatus.STATUS.SERVER_ERROR,result.getStatus().getStatus());
assertEquals(systemException.toString(),result.getStatus().getMessage());
verify(request,resource,query,predicate);
}
InternalCallVerifier EqualityVerifier mapPartialResponseFields=new HashMap();
mapPartialResponseFields.put("foo/bar",null);
Renderer renderer=new DefaultRenderer();
expect(request.getResource()).andReturn(resource);
expect(request.getFields()).andReturn(mapPartialResponseFields);
expect(request.getRenderer()).andReturn(renderer);
expect(resource.getQuery()).andReturn(query);
query.setPageRequest(null);
query.setSortRequest(null);
query.setRenderer(renderer);
query.addProperty("foo/bar",null);
expectLastCall().andThrow(new IllegalArgumentException("testMsg"));
replay(request,resource,query);
ReadHandler handler=new ReadHandler();
Result result=handler.handleRequest(request);
assertEquals(ResultStatus.STATUS.BAD_REQUEST,result.getStatus().getStatus());
assertEquals("testMsg",result.getStatus().getMessage());
verify(request,resource,query);
}
InternalCallVerifier EqualityVerifier emptyMap());
expect(request.getQueryPredicate()).andReturn(predicate);
query.setUserPredicate(predicate);
query.setPageRequest(null);
query.setSortRequest(null);
query.setRenderer(renderer);
expect(query.execute()).andThrow(exception);
replay(request,resource,query,predicate);
ReadHandler handler=new ReadHandler();
Result result=handler.handleRequest(request);
assertEquals(ResultStatus.STATUS.NOT_FOUND,result.getStatus().getStatus());
assertEquals("exceptionMsg",result.getStatus().getMessage());
verify(request,resource,query,predicate);
}
InternalCallVerifier EqualityVerifier emptyMap());
expect(request.getQueryPredicate()).andReturn(predicate);
query.setUserPredicate(predicate);
query.setPageRequest(null);
query.setSortRequest(null);
query.setRenderer(renderer);
AuthorizationException authorizationException=new AuthorizationException("testMsg");
expect(query.execute()).andThrow(authorizationException);
replay(request,resource,query,predicate);
ReadHandler handler=new ReadHandler();
Result result=handler.handleRequest(request);
assertEquals(ResultStatus.STATUS.FORBIDDEN,result.getStatus().getStatus());
assertEquals(authorizationException.getMessage(),result.getStatus().getMessage());
verify(request,resource,query,predicate);
}
InternalCallVerifier EqualityVerifier emptyMap());
expect(request.getQueryPredicate()).andReturn(predicate);
query.setUserPredicate(predicate);
query.setPageRequest(null);
query.setSortRequest(null);
query.setRenderer(renderer);
expect(query.execute()).andThrow(exception);
replay(request,resource,query,predicate);
ReadHandler handler=new ReadHandler();
Result result=handler.handleRequest(request);
assertEquals(ResultStatus.STATUS.BAD_REQUEST,result.getStatus().getStatus());
assertEquals(exception.getMessage(),result.getStatus().getMessage());
verify(request,resource,query,predicate);
}
InternalCallVerifier EqualityVerifier emptyMap());
expect(request.getQueryPredicate()).andReturn(predicate).anyTimes();
query.setUserPredicate(predicate);
query.setPageRequest(null);
query.setSortRequest(null);
query.setRenderer(renderer);
expect(query.execute()).andThrow(exception);
replay(request,resource,query,predicate);
ReadHandler handler=new ReadHandler();
Result result=handler.handleRequest(request);
assertEquals(ResultStatus.STATUS.OK,result.getStatus().getStatus());
verify(request,resource,query,predicate);
}
InternalCallVerifier EqualityVerifier emptyMap());
expect(request.getQueryPredicate()).andReturn(null).anyTimes();
query.setUserPredicate(null);
query.setPageRequest(null);
query.setSortRequest(null);
query.setRenderer(renderer);
expect(query.execute()).andThrow(exception);
replay(request,resource,query);
ReadHandler handler=new ReadHandler();
Result result=handler.handleRequest(request);
assertEquals(ResultStatus.STATUS.NOT_FOUND,result.getStatus().getStatus());
assertEquals(exception.getMessage(),result.getStatus().getMessage());
verify(request,resource,query);
}
InternalCallVerifier IdentityVerifier EqualityVerifier HybridVerifier resultStatusCapture=new Capture();
Map mapPartialResponseFields=new HashMap();
mapPartialResponseFields.put("foo",null);
mapPartialResponseFields.put("bar/c",null);
mapPartialResponseFields.put("bar/d/e",null);
mapPartialResponseFields.put("category/",null);
expect(request.getResource()).andReturn(resource);
expect(resource.getQuery()).andReturn(query);
expect(request.getPageRequest()).andReturn(null);
expect(request.getSortRequest()).andReturn(null);
expect(request.getRenderer()).andReturn(renderer);
expect(request.getFields()).andReturn(mapPartialResponseFields);
query.addProperty("foo",null);
query.addProperty("bar/c",null);
query.addProperty("bar/d/e",null);
query.addProperty("category/",null);
expect(request.getQueryPredicate()).andReturn(predicate);
query.setUserPredicate(predicate);
query.setPageRequest(null);
query.setSortRequest(null);
query.setRenderer(renderer);
expect(query.execute()).andReturn(result);
result.setResultStatus(capture(resultStatusCapture));
replay(request,resource,query,predicate,result);
ReadHandler handler=new ReadHandler();
assertSame(result,handler.handleRequest(request));
assertEquals(ResultStatus.STATUS.OK,resultStatusCapture.getValue().getStatus());
verify(request,resource,query,predicate,result);
}
Class: org.apache.ambari.server.api.handlers.UpdateHandlerTest BranchVerifier UtilityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier setResources=new HashSet();
setResources.add(resource1);
setResources.add(resource2);
expect(request.getResource()).andReturn(resource).anyTimes();
expect(request.getBody()).andReturn(body).anyTimes();
expect(request.getQueryPredicate()).andReturn(userPredicate).atLeastOnce();
expect(request.getRenderer()).andReturn(renderer);
expect(resource.getQuery()).andReturn(query).atLeastOnce();
query.setRenderer(renderer);
query.setUserPredicate(userPredicate);
expect(pm.update(resource,body)).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Accepted);
expect(status.getAssociatedResources()).andReturn(setResources);
expect(resource1.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(resource2.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(status.getRequestResource()).andReturn(requestResource).anyTimes();
replay(request,body,resource,pm,status,resource1,resource2,requestResource,userPredicate,query);
Result result=new TestUpdateHandler(pm).handleRequest(request);
assertNotNull(result);
TreeNode tree=result.getResultTree();
assertEquals(2,tree.getChildren().size());
TreeNode resourcesNode=tree.getChild("resources");
assertEquals(2,resourcesNode.getChildren().size());
boolean foundResource1=false;
boolean foundResource2=false;
for ( TreeNode child : resourcesNode.getChildren()) {
Resource r=child.getObject();
if (r == resource1 && !foundResource1) {
foundResource1=true;
}
else if (r == resource2 && !foundResource2) {
foundResource2=true;
}
else {
fail();
}
}
TreeNode statusNode=tree.getChild("request");
assertNotNull(statusNode);
assertEquals(0,statusNode.getChildren().size());
assertSame(requestResource,statusNode.getObject());
assertEquals(ResultStatus.STATUS.ACCEPTED,result.getStatus().getStatus());
verify(request,body,resource,pm,status,resource1,resource2,requestResource,userPredicate,query);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier setResources=new HashSet();
setResources.add(resource1);
setResources.add(resource2);
expect(request.getResource()).andReturn(resource).anyTimes();
expect(request.getBody()).andReturn(body).anyTimes();
expect(request.getQueryPredicate()).andReturn(userPredicate).atLeastOnce();
expect(request.getRenderer()).andReturn(renderer);
expect(resource.getQuery()).andReturn(query).atLeastOnce();
query.setRenderer(renderer);
query.setUserPredicate(userPredicate);
expect(pm.update(resource,body)).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Complete);
expect(status.getAssociatedResources()).andReturn(setResources);
expect(resource1.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(resource2.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(request,body,resource,pm,status,resource1,resource2,userPredicate,query);
Result result=new TestUpdateHandler(pm).handleRequest(request);
assertNotNull(result);
TreeNode tree=result.getResultTree();
assertEquals(1,tree.getChildren().size());
TreeNode resourcesNode=tree.getChild("resources");
assertEquals(2,resourcesNode.getChildren().size());
boolean foundResource1=false;
boolean foundResource2=false;
for ( TreeNode child : resourcesNode.getChildren()) {
Resource r=child.getObject();
if (r == resource1 && !foundResource1) {
foundResource1=true;
}
else if (r == resource2 && !foundResource2) {
foundResource2=true;
}
else {
fail();
}
}
assertEquals(ResultStatus.STATUS.OK,result.getStatus().getStatus());
verify(request,body,resource,pm,status,resource1,resource2,userPredicate,query);
}
BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier setResources=new HashSet();
setResources.add(resource1);
setResources.add(resource2);
expect(request.getResource()).andReturn(resource).anyTimes();
expect(request.getBody()).andReturn(body).anyTimes();
expect(request.getQueryPredicate()).andReturn(userPredicate).atLeastOnce();
expect(request.getRenderer()).andReturn(renderer);
expect(resource.getQuery()).andReturn(query).atLeastOnce();
query.setRenderer(renderer);
query.setUserPredicate(userPredicate);
expect(pm.update(resource,body)).andReturn(status);
expect(status.getStatus()).andReturn(RequestStatus.Status.Complete);
expect(status.getAssociatedResources()).andReturn(setResources);
expect(resource1.getType()).andReturn(Resource.Type.Cluster).anyTimes();
expect(resource2.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(request,body,resource,pm,status,resource1,resource2,userPredicate,query);
Result result=new TestUpdateHandler(pm).handleRequest(request);
assertNotNull(result);
TreeNode tree=result.getResultTree();
assertEquals(1,tree.getChildren().size());
TreeNode resourcesNode=tree.getChild("resources");
assertEquals(2,resourcesNode.getChildren().size());
boolean foundResource1=false;
boolean foundResource2=false;
for ( TreeNode child : resourcesNode.getChildren()) {
Resource r=child.getObject();
if (r == resource1 && !foundResource1) {
foundResource1=true;
}
else if (r == resource2 && !foundResource2) {
foundResource2=true;
}
else {
fail();
}
}
assertEquals(ResultStatus.STATUS.OK,result.getStatus().getStatus());
verify(request,body,resource,pm,status,resource1,resource2,userPredicate,query);
}
Class: org.apache.ambari.server.api.predicate.QueryLexerTest InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("fields=foo,bar&foo=1");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("fields=a/b&foo=1&_=5555555");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("foo=1&fields=foo,bar");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("foo=1&fields=a/b&_=5555555");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("foo=1&_=11111");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.BRACKET_OPEN,"("));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR_FUNC,".matches("));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"StackConfigurations/property_type"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"(([^=])|=|!=),.in(&).*USER.*.isEmpty(a).matches(b)"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"|"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR_FUNC,".matches("));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"StackConfigurations/property_type"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"fields format to from .*GROUP.*"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("(StackConfigurations/property_type.matches((([^=])|=|!=),.in(&).*USER.*" + ".isEmpty(a).matches(b))|StackConfigurations/property_type.matches(fields format to from .*GROUP.*))");
assertArrayEquals("All characters between \".matches(\" and corresponding closing \")\" bracket should " + "come to VALUE_OPERAND.",listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR_FUNC,".matches("));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"StackConfigurations/property_type"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"(.*USER.*)|(.*GROUP.*)"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("StackConfigurations/property_type.matches((.*USER.*)|(.*GROUP.*))");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("fields=a/b&_=5555555&foo=1");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("format=default&foo=1");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR_FUNC,".in("));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"one, two, 3"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.LOGICAL_UNARY_OPERATOR,"!"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"<"));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"5"));
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"bar"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"2"));
QueryLexer lexer=new QueryLexer();
Set propertiesToIgnore=new HashSet();
propertiesToIgnore.add("ignore1");
propertiesToIgnore.add("otherIgnore");
propertiesToIgnore.add("ba");
propertiesToIgnore.add("ple");
Token[] tokens=lexer.tokens("ba=gone&foo=1&ignore1=pleaseIgnoreMe&fields=a/b&bar=2&otherIgnore=byebye",propertiesToIgnore);
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"bar"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"2"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("foo=1&fields=a/b,c&_=123&bar=2");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR_FUNC,".isEmpty("));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"category1"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"<"));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"a"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.BRACKET_OPEN,"("));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"<="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"b"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"2"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.BRACKET_OPEN,"("));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,">="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"c"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"3"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"|"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"!="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"d"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"4"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("a<1&(b<=2&(c>=3|d!=4))");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("_=111111&foo=1");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("foo=1&format=foo");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"bar"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"2"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("foo=1&fields=a/b&bar=2");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"a"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.BRACKET_OPEN,"("));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"<="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"b"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"2"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"|"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,">"));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"c"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"3"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
QueryLexer lexer=new QueryLexer();
Token[] tokens=lexer.tokens("a=1&(b<=2|c>3)");
assertArrayEquals(listTokens.toArray(new Token[listTokens.size()]),tokens);
}
Class: org.apache.ambari.server.api.predicate.QueryParserTest APIUtilityVerifier InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR_FUNC,".in("));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"one,two,3"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
QueryParser parser=new QueryParser();
Predicate p=parser.parse(listTokens.toArray(new Token[listTokens.size()]));
EqualsPredicate ep1=new EqualsPredicate("foo","one");
EqualsPredicate ep2=new EqualsPredicate("foo","two");
EqualsPredicate ep3=new EqualsPredicate("foo","3");
OrPredicate orPredicate=new OrPredicate(ep1,ep2,ep3);
assertEquals(orPredicate,p);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"a"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.LOGICAL_UNARY_OPERATOR,"!"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"b"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"2"));
QueryParser parser=new QueryParser();
Predicate p=parser.parse(listTokens.toArray(new Token[listTokens.size()]));
EqualsPredicate aPred=new EqualsPredicate("a","1");
EqualsPredicate bPred=new EqualsPredicate("b","2");
NotPredicate notPred=new NotPredicate(bPred);
AndPredicate andPred=new AndPredicate(aPred,notPred);
assertEquals(andPred,p);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.LOGICAL_UNARY_OPERATOR,"!"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"a"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"b"));
QueryParser parser=new QueryParser();
Predicate p=parser.parse(listTokens.toArray(new Token[listTokens.size()]));
assertEquals(new NotPredicate(new EqualsPredicate("a","b")),p);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR_FUNC,".isEmpty("));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"category1"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
QueryParser parser=new QueryParser();
Predicate p=parser.parse(listTokens.toArray(new Token[listTokens.size()]));
assertEquals(new CategoryIsEmptyPredicate("category1"),p);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR_FUNC,".matches("));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,".*"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
QueryParser parser=new QueryParser();
Predicate p=parser.parse(listTokens.toArray(new Token[listTokens.size()]));
FilterPredicate fp=new FilterPredicate("foo",".*");
assertEquals(fp,p);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"foo"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"bar"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.BRACKET_OPEN,"("));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"<"));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"a"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"1"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.BRACKET_OPEN,"("));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"<="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"b"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"2"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"|"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,">"));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"c"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"3"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,">="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"d"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"100"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"|"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"!="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"e"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"5"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"&"));
listTokens.add(new Token(Token.TYPE.LOGICAL_UNARY_OPERATOR,"!"));
listTokens.add(new Token(Token.TYPE.BRACKET_OPEN,"("));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"f"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"6"));
listTokens.add(new Token(Token.TYPE.LOGICAL_OPERATOR,"|"));
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"g"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"7"));
listTokens.add(new Token(Token.TYPE.BRACKET_CLOSE,")"));
QueryParser parser=new QueryParser();
Predicate p=parser.parse(listTokens.toArray(new Token[listTokens.size()]));
EqualsPredicate fooPred=new EqualsPredicate("foo","bar");
LessPredicate aPred=new LessPredicate("a","1");
LessEqualsPredicate bPred=new LessEqualsPredicate("b","2");
GreaterEqualsPredicate cPred=new GreaterEqualsPredicate("c","3");
GreaterEqualsPredicate dPred=new GreaterEqualsPredicate("d","100");
NotPredicate ePred=new NotPredicate(new EqualsPredicate("e","5"));
EqualsPredicate fPred=new EqualsPredicate("f","6");
EqualsPredicate gPRed=new EqualsPredicate("g","7");
OrPredicate bORcPred=new OrPredicate(bPred,cPred);
AndPredicate aANDbORcPred=new AndPredicate(aPred,bORcPred);
AndPredicate aANDbORcANDdPred=new AndPredicate(aANDbORcPred,dPred);
AndPredicate fooANDaANDbORcANDdPred=new AndPredicate(fooPred,aANDbORcANDdPred);
OrPredicate fORgPred=new OrPredicate(fPred,gPRed);
NotPredicate NOTfORgPred=new NotPredicate(fORgPred);
AndPredicate eANDNOTfORgPred=new AndPredicate(ePred,NOTfORgPred);
OrPredicate rootPredicate=new OrPredicate(fooANDaANDbORcANDdPred,eANDNOTfORgPred);
assertEquals(rootPredicate,p);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier listTokens=new ArrayList();
listTokens.add(new Token(Token.TYPE.RELATIONAL_OPERATOR,"="));
listTokens.add(new Token(Token.TYPE.PROPERTY_OPERAND,"a"));
listTokens.add(new Token(Token.TYPE.VALUE_OPERAND,"b"));
QueryParser parser=new QueryParser();
Predicate p=parser.parse(listTokens.toArray(new Token[listTokens.size()]));
assertEquals(new EqualsPredicate("a","b"),p);
}
Class: org.apache.ambari.server.api.query.ExtendedResourcePredicateVisitorTest InternalCallVerifier BooleanVerifier resource1SubProperties1=new HashMap();
resource1SubProperties1.put("sub1/category/p1",1);
resource1SubProperties1.put("sub1/category/p2",2);
resource1SubProperties1.put("sub1/category/p3",3);
Map resource1SubProperties2=new HashMap();
resource1SubProperties2.put("sub1/category/p1",1);
resource1SubProperties2.put("sub1/category/p2",4);
resource1SubProperties2.put("sub1/category/p3",6);
Map resource1SubProperties3=new HashMap();
resource1SubProperties3.put("sub1/category/p1",1);
resource1SubProperties3.put("sub1/category/p2",8);
resource1SubProperties3.put("sub1/category/p3",12);
Set> resource1SubPropertiesSet=new HashSet>();
resource1SubPropertiesSet.add(resource1SubProperties1);
resource1SubPropertiesSet.add(resource1SubProperties2);
resource1SubPropertiesSet.add(resource1SubProperties3);
Map resource2SubProperties1=new HashMap();
resource2SubProperties1.put("sub1/category/p1",2);
resource2SubProperties1.put("sub1/category/p2",2);
resource2SubProperties1.put("sub1/category/p3",3);
Map resource2SubProperties2=new HashMap();
resource2SubProperties2.put("sub1/category/p1",2);
resource2SubProperties2.put("sub1/category/p2",4);
resource2SubProperties2.put("sub1/category/p3",6);
Map resource2SubProperties3=new HashMap();
resource2SubProperties3.put("sub1/category/p1",2);
resource2SubProperties3.put("sub1/category/p2",8);
resource2SubProperties3.put("sub1/category/p3",12);
Set> resource2SubPropertiesSet=new HashSet>();
resource2SubPropertiesSet.add(resource2SubProperties1);
resource2SubPropertiesSet.add(resource2SubProperties2);
resource2SubPropertiesSet.add(resource2SubProperties3);
Map>> extendedPropertyMap=new HashMap>>();
extendedPropertyMap.put(resource1,resource1SubPropertiesSet);
extendedPropertyMap.put(resource2,resource2SubPropertiesSet);
Predicate predicate=new PredicateBuilder().property("sub1/category/p1").equals(1).toPredicate();
ExtendedResourcePredicateVisitor visitor=new ExtendedResourcePredicateVisitor(extendedPropertyMap);
PredicateHelper.visit(predicate,visitor);
Predicate extendedPredicate=visitor.getExtendedPredicate();
Assert.assertTrue(extendedPredicate.evaluate(resource1));
Assert.assertFalse(extendedPredicate.evaluate(resource2));
predicate=new PredicateBuilder().property("sub1/category/p1").equals(2).toPredicate();
visitor=new ExtendedResourcePredicateVisitor(extendedPropertyMap);
PredicateHelper.visit(predicate,visitor);
extendedPredicate=visitor.getExtendedPredicate();
Assert.assertFalse(extendedPredicate.evaluate(resource1));
Assert.assertTrue(extendedPredicate.evaluate(resource2));
predicate=new PredicateBuilder().property("sub1/category/p2").equals(4).toPredicate();
visitor=new ExtendedResourcePredicateVisitor(extendedPropertyMap);
PredicateHelper.visit(predicate,visitor);
extendedPredicate=visitor.getExtendedPredicate();
Assert.assertTrue(extendedPredicate.evaluate(resource1));
Assert.assertTrue(extendedPredicate.evaluate(resource2));
predicate=new PredicateBuilder().property("sub1/category/p2").equals(5).toPredicate();
visitor=new ExtendedResourcePredicateVisitor(extendedPropertyMap);
PredicateHelper.visit(predicate,visitor);
extendedPredicate=visitor.getExtendedPredicate();
Assert.assertFalse(extendedPredicate.evaluate(resource1));
Assert.assertFalse(extendedPredicate.evaluate(resource2));
predicate=new PredicateBuilder().not().property("sub1/category/p2").equals(5).toPredicate();
visitor=new ExtendedResourcePredicateVisitor(extendedPropertyMap);
PredicateHelper.visit(predicate,visitor);
extendedPredicate=visitor.getExtendedPredicate();
Assert.assertTrue(extendedPredicate.evaluate(resource1));
Assert.assertTrue(extendedPredicate.evaluate(resource2));
predicate=new PredicateBuilder().property("sub1/category/p1").equals(1).and().property("sub1/category/p2").equals(4).toPredicate();
visitor=new ExtendedResourcePredicateVisitor(extendedPropertyMap);
PredicateHelper.visit(predicate,visitor);
extendedPredicate=visitor.getExtendedPredicate();
Assert.assertTrue(extendedPredicate.evaluate(resource1));
Assert.assertFalse(extendedPredicate.evaluate(resource2));
predicate=new PredicateBuilder().property("sub1/category/p1").equals(1).or().property("sub1/category/p2").equals(4).toPredicate();
visitor=new ExtendedResourcePredicateVisitor(extendedPropertyMap);
PredicateHelper.visit(predicate,visitor);
extendedPredicate=visitor.getExtendedPredicate();
Assert.assertTrue(extendedPredicate.evaluate(resource1));
Assert.assertTrue(extendedPredicate.evaluate(resource2));
}
Class: org.apache.ambari.server.api.query.ProcessingPredicateVisitorTest InternalCallVerifier EqualityVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Host,null);
QueryImpl instance=new QueryImplTest.TestQuery(mapIds,resourceDefinition);
Predicate notPredicate1=new PredicateBuilder().not().property("host_components/HostRoles/component_name").equals("ZOOKEEPER_SERVER").toPredicate();
Predicate notPredicate2=new PredicateBuilder().not().property("host_components/HostRoles/component_name").equals("HBASE_MASTER").toPredicate();
Predicate andPredicate=new AndPredicate(notPredicate1,notPredicate2);
ProcessingPredicateVisitor visitor=new ProcessingPredicateVisitor(instance);
PredicateHelper.visit(andPredicate,visitor);
Set categories=visitor.getSubResourceCategories();
Assert.assertEquals(categories.iterator().next(),"host_components");
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Stack,"HDP");
QueryImpl instance=new QueryImplTest.TestQuery(mapIds,resourceDefinition);
Predicate predicate=new PredicateBuilder().property("Stacks/stack_name").equals("HDP").and().property("versions/stackServices/StackServices/service_name").equals("HBASE").and().property("versions/operatingSystems/OperatingSystems/os_type").equals("centos5").toPredicate();
ProcessingPredicateVisitor visitor=new ProcessingPredicateVisitor(instance);
PredicateHelper.visit(predicate,visitor);
Set categories=visitor.getSubResourceCategories();
Set expected=new HashSet();
expected.add("versions");
Assert.assertEquals(expected,categories);
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Stack,"HDP");
QueryImpl instance=new QueryImplTest.TestQuery(mapIds,resourceDefinition);
Predicate predicate=new PredicateBuilder().property("Stacks/stack_name").equals("HDP").and().property("versions/stackServices/StackServices/service_name").equals("HBASE").and().property("versions/operatingSystems/OperatingSystems/os_type").equals("centos5").toPredicate();
ProcessingPredicateVisitor visitor=new ProcessingPredicateVisitor(instance);
PredicateHelper.visit(predicate,visitor);
Predicate processedPredicate=visitor.getProcessedPredicate();
Predicate expectedPredicate=new PredicateBuilder().property("Stacks/stack_name").equals("HDP").toPredicate();
Assert.assertEquals(expectedPredicate,processedPredicate);
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Stack,"HDP");
QueryImpl instance=new QueryImplTest.TestQuery(mapIds,resourceDefinition);
Predicate predicate=new PredicateBuilder().property("Stacks/stack_name").equals("HDP").and().property("versions/stackServices/StackServices/service_name").equals("HBASE").and().property("versions/operatingSystems/OperatingSystems/os_type").equals("centos5").toPredicate();
ProcessingPredicateVisitor visitor=new ProcessingPredicateVisitor(instance);
PredicateHelper.visit(predicate,visitor);
Set properties=visitor.getSubResourceProperties();
Set expected=new HashSet();
expected.add("versions/stackServices/StackServices/service_name");
expected.add("versions/operatingSystems/OperatingSystems/os_type");
Assert.assertEquals(expected,properties);
}
Class: org.apache.ambari.server.api.query.QueryImplTest InternalCallVerifier EqualityVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Cluster,"cluster");
expect(resourceDefinition.getType()).andReturn(Resource.Type.Cluster).anyTimes();
Set setChildren=new HashSet();
setChildren.add(new SubResourceDefinition(Resource.Type.Host));
expect(resourceDefinition.getSubResourceDefinitions()).andReturn(setChildren).anyTimes();
replay(resourceDefinition);
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
Result result=instance.execute();
verify(resourceDefinition);
TreeNode tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
TreeNode clusterNode=tree.getChild("Cluster:1");
Assert.assertEquals("Cluster:1",clusterNode.getName());
Assert.assertEquals(Resource.Type.Cluster,clusterNode.getObject().getType());
Assert.assertEquals(1,clusterNode.getChildren().size());
TreeNode hostNode=clusterNode.getChild("hosts");
Assert.assertEquals(4,hostNode.getChildren().size());
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Host).anyTimes();
Set setChildren=new HashSet();
expect(resourceDefinition.getSubResourceDefinitions()).andReturn(setChildren).anyTimes();
replay(resourceDefinition);
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.property("Hosts/host_name").equals("host:2").toPredicate();
instance.setUserPredicate(predicate);
Result result=instance.execute();
verify(resourceDefinition);
TreeNode tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
TreeNode hostNode=tree.getChild("Host:1");
Assert.assertEquals("Host:1",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertEquals("host:2",hostNode.getObject().getPropertyValue("Hosts/host_name"));
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Stack,"HDP");
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
Result result=instance.execute();
TreeNode tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
TreeNode stackNode=tree.getChild("Stack:1");
Assert.assertEquals("Stack:1",stackNode.getName());
Assert.assertEquals(Resource.Type.Stack,stackNode.getObject().getType());
Assert.assertEquals(1,stackNode.getChildren().size());
TreeNode versionsNode=stackNode.getChild("versions");
Assert.assertEquals(3,versionsNode.getChildren().size());
}
InternalCallVerifier BooleanVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Cluster,"cluster");
mapIds.put(Resource.Type.Service,"service");
expect(resourceDefinition.getType()).andReturn(Resource.Type.Service).anyTimes();
expect(resourceDefinition.getSubResourceDefinitions()).andReturn(Collections.emptySet()).anyTimes();
replay(resourceDefinition);
ResourceInstance instance=new TestQuery(mapIds,resourceDefinition);
assertFalse(instance.isCollectionResource());
verify(resourceDefinition);
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Cluster,"cluster");
expect(resourceDefinition.getType()).andReturn(Resource.Type.Host).anyTimes();
Set setChildren=new HashSet();
expect(resourceDefinition.getSubResourceDefinitions()).andReturn(setChildren).anyTimes();
replay(resourceDefinition);
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.property("Hosts/host_name").equals("host:2").toPredicate();
instance.setUserPredicate(predicate);
Result result=instance.execute();
verify(resourceDefinition);
TreeNode tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
TreeNode hostNode=tree.getChild("Host:1");
Assert.assertEquals("Host:1",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertEquals("host:2",hostNode.getObject().getPropertyValue("Hosts/host_name"));
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Stack,"HDP");
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.property("versions/operating_systems/OperatingSystems/os_type").equals("centos5").toPredicate();
instance.setUserPredicate(predicate);
Result result=instance.execute();
TreeNode tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
TreeNode stackNode=tree.getChild("Stack:1");
Assert.assertEquals("Stack:1",stackNode.getName());
Assert.assertEquals(Resource.Type.Stack,stackNode.getObject().getType());
Assert.assertEquals(1,stackNode.getChildren().size());
TreeNode versionsNode=stackNode.getChild("versions");
Assert.assertEquals(3,versionsNode.getChildren().size());
TreeNode versionNode=versionsNode.getChild("StackVersion:1");
Assert.assertEquals("StackVersion:1",versionNode.getName());
Assert.assertEquals(Resource.Type.StackVersion,versionNode.getObject().getType());
Assert.assertEquals(1,versionNode.getChildren().size());
TreeNode opSystemsNode=versionNode.getChild("operating_systems");
Assert.assertEquals(1,opSystemsNode.getChildren().size());
TreeNode opSystemNode=opSystemsNode.getChild("OperatingSystem:1");
Assert.assertEquals("OperatingSystem:1",opSystemNode.getName());
Resource osResource=opSystemNode.getObject();
Assert.assertEquals(Resource.Type.OperatingSystem,opSystemNode.getObject().getType());
Assert.assertEquals("centos5",osResource.getPropertyValue("OperatingSystems/os_type"));
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Stack,"HDP");
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
instance.addProperty("versions/*",null);
instance.addProperty("versions/operating_systems/*",null);
instance.addProperty("versions/operating_systems/repositories/*",null);
Result result=instance.execute();
TreeNode tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
TreeNode stackNode=tree.getChild("Stack:1");
Assert.assertEquals("Stack:1",stackNode.getName());
Assert.assertEquals(Resource.Type.Stack,stackNode.getObject().getType());
Assert.assertEquals(1,stackNode.getChildren().size());
TreeNode versionsNode=stackNode.getChild("versions");
Assert.assertEquals(3,versionsNode.getChildren().size());
TreeNode versionNode=versionsNode.getChild("StackVersion:1");
Assert.assertEquals("StackVersion:1",versionNode.getName());
Assert.assertEquals(Resource.Type.StackVersion,versionNode.getObject().getType());
Assert.assertEquals(6,versionNode.getChildren().size());
TreeNode opSystemsNode=versionNode.getChild("operating_systems");
Assert.assertEquals(3,opSystemsNode.getChildren().size());
TreeNode opSystemNode=opSystemsNode.getChild("OperatingSystem:1");
Assert.assertEquals("OperatingSystem:1",opSystemNode.getName());
Assert.assertEquals(Resource.Type.OperatingSystem,opSystemNode.getObject().getType());
Assert.assertEquals(1,opSystemNode.getChildren().size());
TreeNode repositoriesNode=opSystemNode.getChild("repositories");
Assert.assertEquals(2,repositoriesNode.getChildren().size());
TreeNode repositoryNode=repositoriesNode.getChild("Repository:1");
Assert.assertEquals("Repository:1",repositoryNode.getName());
Resource repositoryResource=repositoryNode.getObject();
Assert.assertEquals(Resource.Type.Repository,repositoryResource.getType());
Assert.assertEquals("repo1",repositoryResource.getPropertyValue("Repositories/repo_id"));
Assert.assertEquals("centos5",repositoryResource.getPropertyValue("Repositories/os_type"));
Assert.assertEquals("1.2.1",repositoryResource.getPropertyValue("Repositories/stack_version"));
Assert.assertEquals("HDP",repositoryResource.getPropertyValue("Repositories/stack_name"));
TreeNode artifactsNode=versionNode.getChild("artifacts");
Assert.assertEquals(1,artifactsNode.getChildren().size());
TreeNode artifactNode=artifactsNode.getChild("StackArtifact:1");
Assert.assertEquals("StackArtifact:1",artifactNode.getName());
Assert.assertEquals(Resource.Type.StackArtifact,artifactNode.getObject().getType());
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Cluster).anyTimes();
Set setChildren=new HashSet();
setChildren.add(new SubResourceDefinition(Resource.Type.Host));
expect(resourceDefinition.getSubResourceDefinitions()).andReturn(setChildren).anyTimes();
replay(resourceDefinition);
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
Result result=instance.execute();
verify(resourceDefinition);
TreeNode tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
TreeNode clusterNode=tree.getChild("Cluster:1");
Assert.assertEquals("Cluster:1",clusterNode.getName());
Assert.assertEquals(Resource.Type.Cluster,clusterNode.getObject().getType());
Assert.assertEquals(0,clusterNode.getChildren().size());
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Host).anyTimes();
Set setChildren=new HashSet();
expect(resourceDefinition.getSubResourceDefinitions()).andReturn(setChildren).anyTimes();
replay(resourceDefinition);
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
Result result=instance.execute();
verify(resourceDefinition);
TreeNode tree=result.getResultTree();
Assert.assertEquals(4,tree.getChildren().size());
TreeNode hostNode=tree.getChild("Host:1");
Assert.assertEquals("Host:1",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
hostNode=tree.getChild("Host:2");
Assert.assertEquals("Host:2",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
hostNode=tree.getChild("Host:3");
Assert.assertEquals("Host:3",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
hostNode=tree.getChild("Host:4");
Assert.assertEquals("Host:4",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
}
InternalCallVerifier BooleanVerifier mapIds=new HashMap();
mapIds.put(Resource.Type.Cluster,"cluster");
mapIds.put(Resource.Type.Service,null);
expect(resourceDefinition.getType()).andReturn(Resource.Type.Service).anyTimes();
expect(resourceDefinition.getSubResourceDefinitions()).andReturn(Collections.emptySet()).anyTimes();
replay(resourceDefinition);
ResourceInstance instance=new TestQuery(mapIds,resourceDefinition);
assertTrue(instance.isCollectionResource());
verify(resourceDefinition);
}
InternalCallVerifier EqualityVerifier iterable=createNiceMock(Iterable.class);
Iterator iterator=createNiceMock(Iterator.class);
expect(clusterController.getSchema(Resource.Type.Cluster)).andReturn(schema).anyTimes();
expect(clusterController.getResources(eq(Resource.Type.Cluster),anyObject(org.apache.ambari.server.controller.spi.Request.class),anyObject(Predicate.class))).andReturn(queryResponse);
expect(clusterController.getIterable(eq(Resource.Type.Cluster),anyObject(QueryResponse.class),anyObject(org.apache.ambari.server.controller.spi.Request.class),anyObject(Predicate.class),anyObject(PageRequest.class),anyObject(SortRequest.class))).andReturn(iterable).anyTimes();
expect(iterable.iterator()).andReturn(iterator).anyTimes();
expect(iterator.hasNext()).andReturn(false).anyTimes();
expect(queryResponse.getResources()).andReturn(Collections.emptySet()).anyTimes();
expect(schema.getKeyPropertyId(Resource.Type.Cluster)).andReturn("Clusters/cluster_name").anyTimes();
TreeNode> treeNode=new TreeNodeImpl>(null,Collections.emptySet(),null);
expect(renderer.finalizeProperties(anyObject(TreeNode.class),anyBoolean())).andReturn(treeNode).anyTimes();
Capture resultCapture=new Capture();
expect(renderer.finalizeResult(capture(resultCapture))).andReturn(null);
replay(clusterController,queryResponse,schema,renderer,iterable,iterator);
QueryImpl query=new TestQuery(new HashMap(),resourceDefinition,clusterController);
query.setRenderer(renderer);
query.execute();
TreeNode tree=resultCapture.getValue().getResultTree();
Assert.assertEquals(0,tree.getChildren().size());
verify(clusterController,queryResponse,schema,renderer,iterable,iterator);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier mapIds=new HashMap();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Host).anyTimes();
Set setChildren=new HashSet();
expect(resourceDefinition.getSubResourceDefinitions()).andReturn(setChildren).anyTimes();
replay(resourceDefinition);
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
instance.addLocalProperty("c1");
Result result=instance.execute();
verify(resourceDefinition);
TreeNode tree=result.getResultTree();
Assert.assertEquals(4,tree.getChildren().size());
TreeNode hostNode=tree.getChild("Host:1");
Assert.assertEquals("Host:1",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p1"));
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p2"));
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p3"));
hostNode=tree.getChild("Host:2");
Assert.assertEquals("Host:2",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p1"));
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p2"));
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p3"));
hostNode=tree.getChild("Host:3");
Assert.assertEquals("Host:3",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p1"));
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p2"));
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p3"));
hostNode=tree.getChild("Host:4");
Assert.assertEquals("Host:4",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p1"));
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p2"));
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p3"));
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
instance.addProperty("operating_systems/*",null);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.property("operating_systems/OperatingSystems/os_type").equals("centos5").toPredicate();
instance.setUserPredicate(predicate);
instance.setPageRequest(new PageRequestImpl(PageRequest.StartingPoint.Beginning,1,0,null,null));
Result result=instance.execute();
TreeNode tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
TreeNode stackVersionNode=tree.getChild("StackVersion:1");
Assert.assertEquals("StackVersion:1",stackVersionNode.getName());
Assert.assertEquals(Resource.Type.StackVersion,stackVersionNode.getObject().getType());
Assert.assertEquals("1.2.1",stackVersionNode.getObject().getPropertyValue("Versions/stack_version"));
QueryImpl instance2=new TestQuery(mapIds,resourceDefinition);
instance2.addProperty("operating_systems/*",null);
instance2.setUserPredicate(predicate);
instance2.setPageRequest(new PageRequestImpl(PageRequest.StartingPoint.OffsetStart,1,1,null,null));
Result result2=instance2.execute();
TreeNode tree2=result2.getResultTree();
Assert.assertEquals(1,tree2.getChildren().size());
TreeNode stackVersionNode2=tree2.getChild("StackVersion:1");
Assert.assertEquals("StackVersion:1",stackVersionNode2.getName());
Assert.assertEquals(Resource.Type.StackVersion,stackVersionNode2.getObject().getType());
Assert.assertEquals("1.2.2",stackVersionNode2.getObject().getPropertyValue("Versions/stack_version"));
QueryImpl instance3=new TestQuery(mapIds,resourceDefinition);
instance3.addProperty("operating_systems/*",null);
instance3.setUserPredicate(predicate);
instance3.setPageRequest(new PageRequestImpl(PageRequest.StartingPoint.OffsetStart,2,1,null,null));
Result result3=instance3.execute();
TreeNode tree3=result3.getResultTree();
Assert.assertEquals(2,tree3.getChildren().size());
TreeNode stackVersionNode3=tree3.getChild("StackVersion:1");
Assert.assertEquals("StackVersion:1",stackVersionNode3.getName());
Assert.assertEquals(Resource.Type.StackVersion,stackVersionNode3.getObject().getType());
Assert.assertEquals("1.2.2",stackVersionNode3.getObject().getPropertyValue("Versions/stack_version"));
stackVersionNode3=tree3.getChild("StackVersion:2");
Assert.assertEquals("StackVersion:2",stackVersionNode3.getName());
Assert.assertEquals(Resource.Type.StackVersion,stackVersionNode3.getObject().getType());
Assert.assertEquals("2.0.1",stackVersionNode3.getObject().getPropertyValue("Versions/stack_version"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier mapIds=new HashMap();
final AtomicInteger pageCallCount=new AtomicInteger(0);
ClusterControllerImpl clusterControllerImpl=new ClusterControllerImpl(new ClusterControllerImplTest.TestProviderModule()){
public PageResponse getPage( Resource.Type type, QueryResponse queryResponse, Request request, Predicate predicate, PageRequest pageRequest, SortRequest sortRequest) throws UnsupportedPropertyException, SystemException, NoSuchResourceException, NoSuchParentResourceException {
pageCallCount.incrementAndGet();
return super.getPage(type,queryResponse,request,predicate,pageRequest,sortRequest);
}
}
;
QueryImpl instance=new TestQuery(mapIds,resourceDefinition,clusterControllerImpl);
pageCallCount.set(0);
Result result=instance.execute();
TreeNode tree=result.getResultTree();
Assert.assertEquals(4,tree.getChildren().size());
Assert.assertEquals(1,pageCallCount.get());
pageCallCount.set(0);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.property("alerts_summary/CRITICAL").greaterThan(0).toPredicate();
instance.setUserPredicate(predicate);
result=instance.execute();
tree=result.getResultTree();
Assert.assertEquals(2,tree.getChildren().size());
Assert.assertEquals(2,pageCallCount.get());
TreeNode hostNode=tree.getChild("Host:1");
Assert.assertEquals("Host:1",hostNode.getName());
Assert.assertEquals("host:0",hostNode.getObject().getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertEquals("1",hostNode.getObject().getPropertyValue(PropertyHelper.getPropertyId("alerts_summary","CRITICAL")));
hostNode=tree.getChild("Host:2");
Assert.assertEquals("Host:2",hostNode.getName());
Assert.assertEquals("host:2",hostNode.getObject().getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertEquals("1",hostNode.getObject().getPropertyValue(PropertyHelper.getPropertyId("alerts_summary","CRITICAL")));
pageCallCount.set(0);
pb=new PredicateBuilder();
predicate=pb.property("alerts_summary/WARNING").greaterThan(0).toPredicate();
instance.setUserPredicate(predicate);
instance.setPageRequest(new PageRequestImpl(PageRequest.StartingPoint.Beginning,1,0,null,null));
result=instance.execute();
tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
Assert.assertEquals(2,pageCallCount.get());
hostNode=tree.getChild("Host:1");
Assert.assertEquals("Host:1",hostNode.getName());
Assert.assertEquals("host:1",hostNode.getObject().getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertEquals("1",hostNode.getObject().getPropertyValue(PropertyHelper.getPropertyId("alerts_summary","WARNING")));
pageCallCount.set(0);
pb=new PredicateBuilder();
predicate=pb.property("alerts_summary/WARNING").greaterThan(0).or().property("host_components/HostRoles/component_name").equals("DATANODE").toPredicate();
instance.setUserPredicate(predicate);
instance.setPageRequest(null);
result=instance.execute();
tree=result.getResultTree();
Assert.assertEquals(0,tree.getChildren().size());
Assert.assertEquals(6,pageCallCount.get());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier mapIds=new HashMap();
expect(resourceDefinition.getType()).andReturn(Resource.Type.Host).anyTimes();
Set setChildren=new HashSet();
expect(resourceDefinition.getSubResourceDefinitions()).andReturn(setChildren).anyTimes();
replay(resourceDefinition);
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
instance.addLocalProperty("c1/p1");
Result result=instance.execute();
verify(resourceDefinition);
TreeNode tree=result.getResultTree();
Assert.assertEquals(4,tree.getChildren().size());
TreeNode hostNode=tree.getChild("Host:1");
Assert.assertEquals("Host:1",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p1"));
hostNode=tree.getChild("Host:2");
Assert.assertEquals("Host:2",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p1"));
hostNode=tree.getChild("Host:3");
Assert.assertEquals("Host:3",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p1"));
hostNode=tree.getChild("Host:4");
Assert.assertEquals("Host:4",hostNode.getName());
Assert.assertEquals(Resource.Type.Host,hostNode.getObject().getType());
Assert.assertNotNull(hostNode.getObject().getPropertyValue("c1/p1"));
}
InternalCallVerifier EqualityVerifier mapIds=new HashMap();
QueryImpl instance=new TestQuery(mapIds,resourceDefinition);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.property("Versions/stack_version").equals("1.2.1").or().property("Versions/stack_version").equals("1.2.2").toPredicate();
instance.setUserPredicate(predicate);
instance.setPageRequest(new PageRequestImpl(PageRequest.StartingPoint.Beginning,1,0,null,null));
Result result=instance.execute();
TreeNode tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
TreeNode stackVersionNode=tree.getChild("StackVersion:1");
Assert.assertEquals("StackVersion:1",stackVersionNode.getName());
Assert.assertEquals(Resource.Type.StackVersion,stackVersionNode.getObject().getType());
Assert.assertEquals("1.2.1",stackVersionNode.getObject().getPropertyValue("Versions/stack_version"));
instance.setPageRequest(new PageRequestImpl(PageRequest.StartingPoint.OffsetStart,1,1,null,null));
result=instance.execute();
tree=result.getResultTree();
Assert.assertEquals(1,tree.getChildren().size());
stackVersionNode=tree.getChild("StackVersion:1");
Assert.assertEquals("StackVersion:1",stackVersionNode.getName());
Assert.assertEquals(Resource.Type.StackVersion,stackVersionNode.getObject().getType());
Assert.assertEquals("1.2.2",stackVersionNode.getObject().getPropertyValue("Versions/stack_version"));
}
Class: org.apache.ambari.server.api.query.SubResourcePredicateVisitorTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.api.query.render.ClusterBlueprintRendererTest APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier testDesiredConfigMap=new HashMap();
DesiredConfig testDesiredConfig=new DesiredConfig();
testDesiredConfig.setTag("test-tag-one");
testDesiredConfigMap.put("test-type-one",testDesiredConfig);
createClusterResultTree(result.getResultTree(),testDesiredConfigMap);
ClusterBlueprintRenderer renderer=new TestBlueprintRenderer(topology);
Result blueprintResult=renderer.finalizeResult(result);
TreeNode blueprintTree=blueprintResult.getResultTree();
assertNull(blueprintTree.getStringProperty("isCollection"));
assertEquals(1,blueprintTree.getChildren().size());
TreeNode blueprintNode=blueprintTree.getChildren().iterator().next();
assertEquals(0,blueprintNode.getChildren().size());
Resource blueprintResource=blueprintNode.getObject();
Map> properties=blueprintResource.getPropertiesMap();
assertEquals("HDP",properties.get("Blueprints").get("stack_name"));
assertEquals("1.3.3",properties.get("Blueprints").get("stack_version"));
Collection> host_groups=(Collection>)properties.get("").get("host_groups");
assertEquals(2,host_groups.size());
for ( Map hostGroupProperties : host_groups) {
String host_group_name=(String)hostGroupProperties.get("name");
if (host_group_name.equals("host_group_1")) {
assertEquals("1",hostGroupProperties.get("cardinality"));
Collection> components=(Collection>)hostGroupProperties.get("components");
assertEquals(5,components.size());
Set expectedValues=new HashSet(Arrays.asList("JOBTRACKER","TASKTRACKER","NAMENODE","DATANODE","AMBARI_SERVER"));
Set actualValues=new HashSet();
for ( Map componentProperties : components) {
assertEquals(1,componentProperties.size());
actualValues.add(componentProperties.get("name"));
}
assertEquals(expectedValues,actualValues);
}
else if (host_group_name.equals("host_group_2")) {
assertEquals("2",hostGroupProperties.get("cardinality"));
Collection> components=(Collection>)hostGroupProperties.get("components");
assertEquals(2,components.size());
Set expectedValues=new HashSet(Arrays.asList("TASKTRACKER","DATANODE"));
Set actualValues=new HashSet();
for ( Map componentProperties : components) {
assertEquals(1,componentProperties.size());
actualValues.add(componentProperties.get("name"));
}
assertEquals(expectedValues,actualValues);
}
}
List>>> configurationsResult=(List>>>)blueprintResource.getPropertyValue("configurations");
assertEquals("Incorrect number of config maps added",1,configurationsResult.size());
Map> configMap=configurationsResult.iterator().next().get("test-type-one");
assertNotNull("Expected config map was not included",configMap);
assertEquals("Incorrect number of maps added under expected type",2,configMap.size());
assertTrue("Expected properties map was not found",configMap.containsKey("properties"));
assertTrue("Expected properties_attributes map was not found",configMap.containsKey("properties_attributes"));
Map propertiesResult=configMap.get("properties");
assertEquals("Incorrect number of config properties found",1,propertiesResult.size());
Map attributesResult=configMap.get("properties_attributes");
assertEquals("Incorrect number of config attributes found",1,attributesResult.size());
assertEquals("Incorrect property value included","valueOne",propertiesResult.get("propertyOne"));
assertNotNull("Expected attribute not found in exported Blueprint",attributesResult.get("final"));
assertTrue("Attribute type map was not included",attributesResult.get("final") instanceof Map);
Map finalMap=(Map)attributesResult.get("final");
assertEquals("Attribute value is not correct","true",finalMap.get("propertyOne"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier ());
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Cluster");
rootQuery.getProperties().add("foo/bar");
rootQuery.getProperties().add("prop1");
QueryInfo hostInfo=new QueryInfo(new HostResourceDefinition(),new HashSet());
queryTree.addChild(hostInfo,"Host");
QueryInfo hostComponentInfo=new QueryInfo(new HostComponentResourceDefinition(),new HashSet());
queryTree.getChild("Host").addChild(hostComponentInfo,"HostComponent");
ClusterBlueprintRenderer renderer=new ClusterBlueprintRenderer();
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
Set rootProperties=propertyTree.getObject();
assertEquals(2,rootProperties.size());
assertNotNull(propertyTree.getChild("Host"));
assertTrue(propertyTree.getChild("Host").getObject().isEmpty());
assertNotNull(propertyTree.getChild("Host/HostComponent"));
assertEquals(1,propertyTree.getChild("Host/HostComponent").getObject().size());
assertTrue(propertyTree.getChild("Host/HostComponent").getObject().contains("HostRoles/component_name"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier ());
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Cluster");
rootQuery.getProperties().add("foo/bar");
rootQuery.getProperties().add("prop1");
ClusterBlueprintRenderer renderer=new ClusterBlueprintRenderer();
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
Set rootProperties=propertyTree.getObject();
assertEquals(2,rootProperties.size());
assertNotNull(propertyTree.getChild("Host"));
assertTrue(propertyTree.getChild("Host").getObject().isEmpty());
assertNotNull(propertyTree.getChild("Host/HostComponent"));
assertEquals(1,propertyTree.getChild("Host/HostComponent").getObject().size());
assertTrue(propertyTree.getChild("Host/HostComponent").getObject().contains("HostRoles/component_name"));
}
APIUtilityVerifier BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier blueprintTree=blueprintResult.getResultTree();
assertNull(blueprintTree.getStringProperty("isCollection"));
assertEquals(1,blueprintTree.getChildren().size());
TreeNode blueprintNode=blueprintTree.getChildren().iterator().next();
assertEquals(0,blueprintNode.getChildren().size());
Resource blueprintResource=blueprintNode.getObject();
Map> properties=blueprintResource.getPropertiesMap();
assertEquals("HDP",properties.get("Blueprints").get("stack_name"));
assertEquals("1.3.3",properties.get("Blueprints").get("stack_version"));
Collection> host_groups=(Collection>)properties.get("").get("host_groups");
assertEquals(2,host_groups.size());
for ( Map hostGroupProperties : host_groups) {
String host_group_name=(String)hostGroupProperties.get("name");
if (host_group_name.equals("host_group_1")) {
assertEquals("1",hostGroupProperties.get("cardinality"));
Collection> components=(Collection>)hostGroupProperties.get("components");
assertEquals(5,components.size());
Set expectedValues=new HashSet(Arrays.asList("JOBTRACKER","TASKTRACKER","NAMENODE","DATANODE","AMBARI_SERVER"));
Set actualValues=new HashSet();
for ( Map componentProperties : components) {
assertEquals(1,componentProperties.size());
actualValues.add(componentProperties.get("name"));
}
assertEquals(expectedValues,actualValues);
}
else if (host_group_name.equals("host_group_2")) {
assertEquals("2",hostGroupProperties.get("cardinality"));
Collection> components=(Collection>)hostGroupProperties.get("components");
assertEquals(2,components.size());
Set expectedValues=new HashSet(Arrays.asList("TASKTRACKER","DATANODE"));
Set actualValues=new HashSet();
for ( Map componentProperties : components) {
assertEquals(1,componentProperties.size());
actualValues.add(componentProperties.get("name"));
}
assertEquals(expectedValues,actualValues);
}
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier blueprintTree=blueprintResult.getResultTree();
assertNull(blueprintTree.getStringProperty("isCollection"));
assertEquals(1,blueprintTree.getChildren().size());
TreeNode blueprintNode=blueprintTree.getChildren().iterator().next();
assertEquals(0,blueprintNode.getChildren().size());
Resource blueprintResource=blueprintNode.getObject();
Map> properties=blueprintResource.getPropertiesMap();
assertEquals("HDP",properties.get("Blueprints").get("stack_name"));
assertEquals("1.3.3",properties.get("Blueprints").get("stack_version"));
Map securityProperties=(Map)properties.get("Blueprints").get("security");
assertEquals("KERBEROS",securityProperties.get("type"));
assertNotNull(((Map)securityProperties.get("kerberos_descriptor")).get("properties"));
}
Class: org.apache.ambari.server.api.query.render.DefaultRendererTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
serviceProperties.add("foo/bar");
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
HashSet componentProperties=new HashSet();
componentProperties.add("goo/car");
queryTree.addChild(new QueryInfo(new ComponentResourceDefinition(),componentProperties),"Component");
DefaultRenderer renderer=new DefaultRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
assertEquals(1,propertyTree.getChildren().size());
assertEquals(3,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("ServiceInfo/cluster_name"));
assertTrue(propertyTree.getObject().contains("foo/bar"));
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(0,componentNode.getChildren().size());
assertEquals(3,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/service_name"));
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
assertTrue(componentNode.getObject().contains("goo/car"));
verify(schemaFactory,serviceSchema,componentSchema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
serviceProperties.add("foo/bar");
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
queryTree.addChild(new QueryInfo(new ComponentResourceDefinition(),new HashSet()),"Component");
DefaultRenderer renderer=new DefaultRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,true);
assertEquals(1,propertyTree.getChildren().size());
assertEquals(3,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("ServiceInfo/cluster_name"));
assertTrue(propertyTree.getObject().contains("foo/bar"));
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(0,componentNode.getChildren().size());
assertEquals(2,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/service_name"));
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
verify(schemaFactory,serviceSchema,componentSchema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
queryTree.addChild(new QueryInfo(new ComponentResourceDefinition(),new HashSet()),"Component");
DefaultRenderer renderer=new DefaultRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
assertEquals(1,propertyTree.getChildren().size());
assertEquals(2,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("ServiceInfo/cluster_name"));
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(0,componentNode.getChildren().size());
assertEquals(2,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/service_name"));
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
verify(schemaFactory,serviceSchema,componentSchema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier ());
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
DefaultRenderer renderer=new DefaultRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
assertTrue(propertyTree.getObject().isEmpty());
assertEquals(3,propertyTree.getChildren().size());
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(2,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/service_name"));
verify(schemaFactory,schema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
DefaultRenderer renderer=new DefaultRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,true);
assertEquals(2,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("ServiceInfo/cluster_name"));
assertEquals(0,propertyTree.getChildren().size());
verify(schemaFactory,schema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
serviceProperties.add("foo/bar");
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
DefaultRenderer renderer=new DefaultRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
assertEquals(3,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("ServiceInfo/cluster_name"));
assertTrue(propertyTree.getObject().contains("foo/bar"));
assertEquals(0,propertyTree.getChildren().size());
verify(schemaFactory,schema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
serviceProperties.add("foo/bar");
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
DefaultRenderer renderer=new DefaultRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,true);
assertEquals(3,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("ServiceInfo/cluster_name"));
assertTrue(propertyTree.getObject().contains("foo/bar"));
assertEquals(0,propertyTree.getChildren().size());
verify(schemaFactory,schema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
queryTree.addChild(new QueryInfo(new ComponentResourceDefinition(),new HashSet()),"Component");
DefaultRenderer renderer=new DefaultRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,true);
assertEquals(1,propertyTree.getChildren().size());
assertEquals(2,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("ServiceInfo/cluster_name"));
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(0,componentNode.getChildren().size());
assertEquals(2,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/service_name"));
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
verify(schemaFactory,serviceSchema,componentSchema);
}
Class: org.apache.ambari.server.api.query.render.MetricsPaddingRendererTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
serviceProperties.add("foo/bar");
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
MetricsPaddingRenderer renderer=new MetricsPaddingRenderer("null_padding");
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
assertEquals(4,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("ServiceInfo/cluster_name"));
assertTrue(propertyTree.getObject().contains("foo/bar"));
assertTrue(propertyTree.getObject().contains("params/padding/NULLS"));
assertEquals(0,propertyTree.getChildren().size());
verify(schemaFactory,schema);
}
Class: org.apache.ambari.server.api.query.render.MinimalRendererTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier ());
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
MinimalRenderer renderer=new MinimalRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
assertTrue(propertyTree.getObject().isEmpty());
assertEquals(3,propertyTree.getChildren().size());
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(1,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
verify(schemaFactory,schema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
MinimalRenderer renderer=new MinimalRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,true);
assertEquals(1,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertEquals(0,propertyTree.getChildren().size());
verify(schemaFactory,schema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
queryTree.addChild(new QueryInfo(new ComponentResourceDefinition(),new HashSet()),"Component");
MinimalRenderer renderer=new MinimalRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
assertEquals(1,propertyTree.getChildren().size());
assertEquals(1,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(0,componentNode.getChildren().size());
assertEquals(1,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
verify(schemaFactory,serviceSchema,componentSchema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
serviceProperties.add("foo/bar");
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
HashSet componentProperties=new HashSet();
componentProperties.add("goo/car");
queryTree.addChild(new QueryInfo(new ComponentResourceDefinition(),componentProperties),"Component");
MinimalRenderer renderer=new MinimalRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
assertEquals(1,propertyTree.getChildren().size());
assertEquals(2,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("foo/bar"));
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(0,componentNode.getChildren().size());
assertEquals(2,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
assertTrue(componentNode.getObject().contains("goo/car"));
verify(schemaFactory,serviceSchema,componentSchema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
serviceProperties.add("foo/bar");
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
MinimalRenderer renderer=new MinimalRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,true);
assertEquals(2,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("foo/bar"));
assertEquals(0,propertyTree.getChildren().size());
verify(schemaFactory,schema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
serviceProperties.add("foo/bar");
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
MinimalRenderer renderer=new MinimalRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,false);
assertEquals(2,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("foo/bar"));
assertEquals(0,propertyTree.getChildren().size());
verify(schemaFactory,schema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier resultTree=renderer.finalizeResult(result).getResultTree();
assertNull(resultTree.getStringProperty("isCollection"));
assertEquals(1,resultTree.getChildren().size());
TreeNode clusterNode=resultTree.getChildren().iterator().next();
Resource clusterResource=clusterNode.getObject();
Map> clusterProperties=clusterResource.getPropertiesMap();
assertEquals(2,clusterProperties.size());
assertEquals(3,clusterProperties.get("Clusters").size());
assertEquals("testCluster",clusterProperties.get("Clusters").get("cluster_name"));
assertEquals("HDP-1.3.3",clusterProperties.get("Clusters").get("version"));
assertEquals("value1",clusterProperties.get("Clusters").get("prop1"));
assertEquals(1,clusterProperties.get("").size());
assertEquals("bar",clusterProperties.get("").get("foo"));
TreeNode hosts=clusterNode.getChildren().iterator().next();
for ( TreeNode hostNode : hosts.getChildren()) {
Resource hostResource=hostNode.getObject();
Map> hostProperties=hostResource.getPropertiesMap();
assertEquals(2,hostProperties.size());
assertEquals(1,hostProperties.get("Hosts").size());
assertTrue(hostProperties.get("Hosts").containsKey("host_name"));
assertEquals(1,hostProperties.get("").size());
assertEquals("bar",hostProperties.get("").get("foo"));
for ( TreeNode componentNode : hostNode.getChildren().iterator().next().getChildren()) {
Resource componentResource=componentNode.getObject();
Map> componentProperties=componentResource.getPropertiesMap();
assertEquals(1,componentProperties.size());
assertEquals(1,componentProperties.get("HostRoles").size());
assertTrue(componentProperties.get("HostRoles").containsKey("component_name"));
}
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier resultTree=renderer.finalizeResult(result).getResultTree();
assertNull(resultTree.getStringProperty("isCollection"));
assertEquals(1,resultTree.getChildren().size());
TreeNode clusterNode=resultTree.getChildren().iterator().next();
Resource clusterResource=clusterNode.getObject();
Map> clusterProperties=clusterResource.getPropertiesMap();
assertEquals(2,clusterProperties.size());
assertEquals(3,clusterProperties.get("Clusters").size());
assertEquals("testCluster",clusterProperties.get("Clusters").get("cluster_name"));
assertEquals("HDP-1.3.3",clusterProperties.get("Clusters").get("version"));
assertEquals("value1",clusterProperties.get("Clusters").get("prop1"));
assertEquals(1,clusterProperties.get("").size());
assertEquals("bar",clusterProperties.get("").get("foo"));
TreeNode hosts=clusterNode.getChildren().iterator().next();
for ( TreeNode hostNode : hosts.getChildren()) {
Resource hostResource=hostNode.getObject();
Map> hostProperties=hostResource.getPropertiesMap();
assertEquals(1,hostProperties.size());
assertEquals(1,hostProperties.get("Hosts").size());
assertTrue(hostProperties.get("Hosts").containsKey("host_name"));
for ( TreeNode componentNode : hostNode.getChildren().iterator().next().getChildren()) {
Resource componentResource=componentNode.getObject();
Map> componentProperties=componentResource.getPropertiesMap();
assertEquals(1,componentProperties.size());
assertEquals(1,componentProperties.get("HostRoles").size());
assertTrue(componentProperties.get("HostRoles").containsKey("component_name"));
}
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
serviceProperties.add("foo/bar");
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
queryTree.addChild(new QueryInfo(new ComponentResourceDefinition(),new HashSet()),"Component");
MinimalRenderer renderer=new MinimalRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,true);
assertEquals(1,propertyTree.getChildren().size());
assertEquals(2,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
assertTrue(propertyTree.getObject().contains("foo/bar"));
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(0,componentNode.getChildren().size());
assertEquals(1,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
verify(schemaFactory,serviceSchema,componentSchema);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceProperties=new HashSet();
QueryInfo rootQuery=new QueryInfo(new ServiceResourceDefinition(),serviceProperties);
TreeNode queryTree=new TreeNodeImpl(null,rootQuery,"Service");
queryTree.addChild(new QueryInfo(new ComponentResourceDefinition(),new HashSet()),"Component");
MinimalRenderer renderer=new MinimalRenderer();
renderer.init(schemaFactory);
TreeNode> propertyTree=renderer.finalizeProperties(queryTree,true);
assertEquals(1,propertyTree.getChildren().size());
assertEquals(1,propertyTree.getObject().size());
assertTrue(propertyTree.getObject().contains("ServiceInfo/service_name"));
TreeNode> componentNode=propertyTree.getChild("Component");
assertEquals(0,componentNode.getChildren().size());
assertEquals(1,componentNode.getObject().size());
assertTrue(componentNode.getObject().contains("ServiceComponentInfo/component_name"));
verify(schemaFactory,serviceSchema,componentSchema);
}
Class: org.apache.ambari.server.api.resources.BaseResourceDefinitionTest InternalCallVerifier EqualityVerifier postProcessors=resourceDefinition.getPostProcessors();
Assert.assertEquals(1,postProcessors.size());
ResourceDefinition.PostProcessor processor=postProcessors.iterator().next();
Resource service=new ResourceImpl(Resource.Type.Service);
service.setProperty("ServiceInfo/service_name","Service1");
TreeNode parentNode=new TreeNodeImpl(null,null,"services");
TreeNode serviceNode=new TreeNodeImpl(parentNode,service,"service1");
parentNode.setProperty("isCollection","true");
ResourceProviderFactory factory=createMock(ResourceProviderFactory.class);
MaintenanceStateHelper maintenanceStateHelper=createNiceMock(MaintenanceStateHelper.class);
AmbariManagementController managementController=createMock(AmbariManagementController.class);
expect(maintenanceStateHelper.isOperationAllowed(anyObject(Resource.Type.class),anyObject(Service.class))).andReturn(true).anyTimes();
ResourceProvider serviceResourceProvider=new ServiceResourceProvider(PropertyHelper.getPropertyIds(Resource.Type.Service),PropertyHelper.getKeyPropertyIds(Resource.Type.Service),managementController,maintenanceStateHelper);
expect(factory.getServiceResourceProvider(anyObject(Set.class),anyObject(Map.class),anyObject(AmbariManagementController.class))).andReturn(serviceResourceProvider);
AbstractControllerResourceProvider.init(factory);
replay(factory,managementController,maintenanceStateHelper);
processor.process(null,serviceNode,"http://c6401.ambari.apache.org:8080/api/v1/clusters/c1/services");
String href=serviceNode.getStringProperty("href");
Assert.assertEquals("http://c6401.ambari.apache.org:8080/api/v1/clusters/c1/services/Service1",href);
Resource configGroup=new ResourceImpl(Resource.Type.ConfigGroup);
configGroup.setProperty("ConfigGroup/id","2");
TreeNode resourcesNode=new TreeNodeImpl(null,null,BaseManagementHandler.RESOURCES_NODE_NAME);
TreeNode configGroupNode=new TreeNodeImpl(resourcesNode,configGroup,"configGroup1");
resourcesNode.setProperty("isCollection","true");
processor.process(null,configGroupNode,"http://c6401.ambari.apache.org:8080/api/v1/clusters/c1/config_groups");
href=configGroupNode.getStringProperty("href");
Assert.assertEquals("http://c6401.ambari.apache.org:8080/api/v1/clusters/c1/config_groups/2",href);
}
UtilityVerifier InternalCallVerifier BooleanVerifier HybridVerifier Class: org.apache.ambari.server.api.resources.BlueprintResourceDefinitionTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier directives=definition.getCreateDirectives();
Assert.assertEquals(1,directives.size());
Assert.assertTrue(directives.contains("validate_topology"));
}
Class: org.apache.ambari.server.api.resources.ClusterResourceDefinitionTest UtilityVerifier InternalCallVerifier BooleanVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResources=resource.getSubResourceDefinitions();
assertEquals(12,subResources.size());
assertTrue(includesType(subResources,Resource.Type.Service));
assertTrue(includesType(subResources,Resource.Type.Host));
assertTrue(includesType(subResources,Resource.Type.Configuration));
assertTrue(includesType(subResources,Resource.Type.Request));
assertTrue(includesType(subResources,Resource.Type.Workflow));
assertTrue(includesType(subResources,Resource.Type.ConfigGroup));
assertTrue(includesType(subResources,Resource.Type.AlertDefinition));
assertTrue(includesType(subResources,Resource.Type.ServiceConfigVersion));
assertTrue(includesType(subResources,Resource.Type.ClusterPrivilege));
assertTrue(includesType(subResources,Resource.Type.Alert));
assertTrue(includesType(subResources,Resource.Type.ClusterStackVersion));
assertTrue(includesType(subResources,Resource.Type.Artifact));
}
Class: org.apache.ambari.server.api.resources.ComponentStackVersionResourceDefinitionTest InternalCallVerifier EqualityVerifier subResourceDefinitions=resourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(1,subResourceDefinitions.size());
}
Class: org.apache.ambari.server.api.resources.CredentialResourceDefinitionTest InternalCallVerifier EqualityVerifier directives=definition.getCreateDirectives();
Assert.assertEquals(0,directives.size());
}
Class: org.apache.ambari.server.api.resources.FeedResourceDefinitionTest APIUtilityVerifier InternalCallVerifier EqualityVerifier subResourceDefinitions=definition.getSubResourceDefinitions();
Assert.assertEquals(1,subResourceDefinitions.size());
SubResourceDefinition subResourceDefinition=subResourceDefinitions.iterator().next();
Assert.assertEquals(Resource.Type.DRInstance,subResourceDefinition.getType());
}
Class: org.apache.ambari.server.api.resources.HostKerberosIdentityResourceDefinitionTest InternalCallVerifier EqualityVerifier subResourceDefinitions=resourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(0,subResourceDefinitions.size());
}
Class: org.apache.ambari.server.api.resources.HostResourceDefinitionTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResources=resource.getSubResourceDefinitions();
assertEquals(4,subResources.size());
assertTrue(includesType(subResources,Resource.Type.HostComponent));
assertTrue(includesType(subResources,Resource.Type.Alert));
assertTrue(includesType(subResources,Resource.Type.HostStackVersion));
assertTrue(includesType(subResources,Resource.Type.HostKerberosIdentity));
}
Class: org.apache.ambari.server.api.resources.InstanceResourceDefinitionTest InternalCallVerifier BooleanVerifier subResourceDefinitions=definition.getSubResourceDefinitions();
Assert.assertTrue(subResourceDefinitions.isEmpty());
}
Class: org.apache.ambari.server.api.resources.JobResourceDefinitionTest APIUtilityVerifier InternalCallVerifier EqualityVerifier subResourceDefinitions=definition.getSubResourceDefinitions();
Assert.assertEquals(1,subResourceDefinitions.size());
SubResourceDefinition subResourceDefinition=subResourceDefinitions.iterator().next();
Assert.assertEquals(Resource.Type.TaskAttempt,subResourceDefinition.getType());
}
Class: org.apache.ambari.server.api.resources.LdapSyncEventResourceDefinitionTest InternalCallVerifier EqualityVerifier subResourceDefinitions=resourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(0,subResourceDefinitions.size());
}
Class: org.apache.ambari.server.api.resources.PermissionResourceDefinitionTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResourceDefinitions=permissionResourceDefinition.getSubResourceDefinitions();
Set expectedSubTypes=new HashSet();
expectedSubTypes.add(Resource.Type.RoleAuthorization);
Assert.assertEquals(1,subResourceDefinitions.size());
for ( SubResourceDefinition subResourceDefinition : subResourceDefinitions) {
Assert.assertTrue(expectedSubTypes.contains(subResourceDefinition.getType()));
}
}
Class: org.apache.ambari.server.api.resources.PrivilegeResourceDefinitionTest InternalCallVerifier EqualityVerifier subResourceDefinitions=privilegeResourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(0,subResourceDefinitions.size());
}
Class: org.apache.ambari.server.api.resources.RepositoryResourceDefinitionTest InternalCallVerifier EqualityVerifier subResourceDefinitions=resourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(0,subResourceDefinitions.size());
}
InternalCallVerifier EqualityVerifier createDirectives=resourceDefinition.getCreateDirectives();
Assert.assertEquals(1,createDirectives.size());
Assert.assertEquals(RepositoryResourceDefinition.VALIDATE_ONLY_DIRECTIVE,createDirectives.iterator().next());
}
Class: org.apache.ambari.server.api.resources.RepositoryVersionResourceDefinitionTest APIUtilityVerifier InternalCallVerifier EqualityVerifier subResourceDefinitions=resourceDefinition.getSubResourceDefinitions();
final Iterator iterator=subResourceDefinitions.iterator();
Assert.assertEquals(Resource.Type.OperatingSystem,iterator.next().getType());
Assert.assertEquals(1,subResourceDefinitions.size());
}
Class: org.apache.ambari.server.api.resources.ResourceInstanceFactoryImplTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.api.resources.ServiceResourceDefinitionTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResources=resource.getSubResourceDefinitions();
assertEquals(3,subResources.size());
assertTrue(includesType(subResources,Resource.Type.Component));
assertTrue(includesType(subResources,Resource.Type.Alert));
assertTrue(includesType(subResources,Resource.Type.Artifact));
}
Class: org.apache.ambari.server.api.resources.StackConfigurationDefinitionTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResources=resource.getSubResourceDefinitions();
assertEquals(1,subResources.size());
assertTrue(includesType(subResources,Resource.Type.StackConfigurationDependency));
}
Class: org.apache.ambari.server.api.resources.StackConfigurationDependencyDefinitionTest InternalCallVerifier BooleanVerifier subResources=resource.getSubResourceDefinitions();
assertTrue(subResources.isEmpty());
}
Class: org.apache.ambari.server.api.resources.StackServiceResourceDefinitionTest InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResources=def.getSubResourceDefinitions();
assertEquals(5,subResources.size());
boolean configReturned=false;
boolean componentReturned=false;
boolean artifactReturned=false;
boolean themesReturned=false;
for ( SubResourceDefinition subResource : subResources) {
Resource.Type type=subResource.getType();
if (type.equals(Resource.Type.StackConfiguration)) {
configReturned=true;
}
else if (type.equals(Resource.Type.StackServiceComponent)) {
componentReturned=true;
}
else if (type.equals(Resource.Type.StackArtifact)) {
artifactReturned=true;
}
else if (type.equals(Resource.Type.Theme)) {
themesReturned=true;
}
}
assertTrue(configReturned);
assertTrue(componentReturned);
assertTrue(artifactReturned);
assertTrue(themesReturned);
}
Class: org.apache.ambari.server.api.resources.StackVersionResourceDefinitionTest InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResources=def.getSubResourceDefinitions();
assertEquals(6,subResources.size());
boolean operatingSystemFound=false;
boolean serviceFound=false;
boolean configFound=false;
boolean repoFound=false;
boolean artifactReturned=false;
boolean compatibleFound=false;
for ( SubResourceDefinition subResource : subResources) {
Resource.Type type=subResource.getType();
if (type.equals(Resource.Type.OperatingSystem)) {
operatingSystemFound=true;
}
else if (type.equals(Resource.Type.StackService)) {
serviceFound=true;
}
else if (type.equals(Resource.Type.StackLevelConfiguration)) {
configFound=true;
}
else if (type.equals(Resource.Type.RepositoryVersion)) {
repoFound=true;
}
else if (type.equals(Resource.Type.StackArtifact)) {
artifactReturned=true;
}
else if (type.equals(Resource.Type.CompatibleRepositoryVersion)) {
compatibleFound=true;
}
}
assertTrue(operatingSystemFound);
assertTrue(serviceFound);
assertTrue(configFound);
assertTrue(repoFound);
assertTrue(artifactReturned);
assertTrue(compatibleFound);
}
Class: org.apache.ambari.server.api.resources.TargetClusterResourceDefinitionTest InternalCallVerifier BooleanVerifier subResourceDefinitions=definition.getSubResourceDefinitions();
Assert.assertTrue(subResourceDefinitions.isEmpty());
}
Class: org.apache.ambari.server.api.resources.TaskAttemptResourceDefinitionTest InternalCallVerifier EqualityVerifier subResourceDefinitions=definition.getSubResourceDefinitions();
Assert.assertEquals(0,subResourceDefinitions.size());
}
Class: org.apache.ambari.server.api.resources.UserResourceDefinitionTest InternalCallVerifier EqualityVerifier subResourceDefinitions=userResourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(2,subResourceDefinitions.size());
}
Class: org.apache.ambari.server.api.resources.ViewInstanceResourceDefinitionTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResourceDefinitions=viewInstanceResourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(3,subResourceDefinitions.size());
for ( SubResourceDefinition subResourceDefinition : subResourceDefinitions) {
Resource.Type type=subResourceDefinition.getType();
Assert.assertTrue(type.name().equals("sub1") || type.name().equals("sub2") || type.equals(Resource.Type.ViewPrivilege));
}
}
Class: org.apache.ambari.server.api.resources.ViewPermissionResourceDefinitionTest InternalCallVerifier BooleanVerifier subResourceDefinitions=ViewPermissionResourceDefinition.getSubResourceDefinitions();
Assert.assertTrue(subResourceDefinitions.isEmpty());
}
Class: org.apache.ambari.server.api.resources.ViewResourceDefinitionTest InternalCallVerifier EqualityVerifier subResourceDefinitions=viewResourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(1,subResourceDefinitions.size());
Assert.assertEquals("ViewVersion",subResourceDefinitions.iterator().next().getType().name());
}
Class: org.apache.ambari.server.api.resources.ViewVersionResourceDefinitionTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResourceDefinitions=viewVersionResourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(2,subResourceDefinitions.size());
for ( SubResourceDefinition subResourceDefinition : subResourceDefinitions) {
String name=subResourceDefinition.getType().name();
Assert.assertTrue(name.equals("ViewInstance") || name.equals("ViewPermission"));
}
}
Class: org.apache.ambari.server.api.resources.WorkflowResourceDefinitionTest APIUtilityVerifier InternalCallVerifier EqualityVerifier subResourceDefinitions=definition.getSubResourceDefinitions();
Assert.assertEquals(1,subResourceDefinitions.size());
SubResourceDefinition subResourceDefinition=subResourceDefinitions.iterator().next();
Assert.assertEquals(Resource.Type.Job,subResourceDefinition.getType());
}
Class: org.apache.ambari.server.api.rest.KdcServerConnectionVerificationTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier IgnoredMethod HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.api.services.AmbariMetaInfoTest APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier redhat6Repo=ambariMetaInfo.getRepositories(STACK_NAME_HDP,"2.1.1","redhat6");
assertNotNull(redhat6Repo);
for ( RepositoryInfo ri : redhat6Repo) {
if (HDP_REPO_NAME.equals(ri.getRepoName())) {
assertEquals(newBaseUrl,ri.getBaseUrl());
assertFalse(ri.getBaseUrl().equals(ri.getDefaultBaseUrl()));
}
}
Capture c=new Capture();
metainfoDAO=ambariMetaInfo.metaInfoDAO;
reset(metainfoDAO);
reset(entity);
expect(metainfoDAO.findByKey("repo:/HDP/2.1.1/redhat6/HDP-2.1.1:baseurl")).andReturn(entity).atLeastOnce();
expect(metainfoDAO.merge(EasyMock.capture(c))).andReturn(entity).atLeastOnce();
replay(metainfoDAO,entity);
ambariMetaInfo.updateRepoBaseURL(STACK_NAME_HDP,"2.1.1","redhat6",HDP_REPO_ID,prevBaseUrl);
assertEquals(prevBaseUrl,c.getValue().getMetainfoValue());
assertTrue(repoInfo.isBaseUrlFromSaved());
}
InternalCallVerifier EqualityVerifier APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier redhat6Repo=ambariMetaInfo.getRepositories(STACK_NAME_HDP,"2.1.1","redhat6");
assertNotNull(redhat6Repo);
for ( RepositoryInfo ri : redhat6Repo) {
if (STACK_NAME_HDP.equals(ri.getRepoName())) {
assertFalse(ri.getBaseUrl().equals(ri.getDefaultBaseUrl()));
assertEquals(ri.getBaseUrl(),ri.getLatestBaseUrl());
}
}
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier getServices(String stackName, String
* version, String serviceName)
* @throws AmbariException
*/
@Test public void getServices() throws AmbariException {
Map services=metaInfo.getServices(STACK_NAME_HDP,STACK_VERSION_HDP);
LOG.info("Getting all the services ");
for ( Map.Entry entry : services.entrySet()) {
LOG.info("Service Name " + entry.getKey() + " values "+ entry.getValue());
}
assertTrue(services.containsKey("HDFS"));
assertTrue(services.containsKey("MAPREDUCE"));
assertNotNull(services);
assertFalse(services.keySet().size() == 0);
}
BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(4,componentList.size());
for ( ComponentInfo component : componentList) {
String name=component.getName();
if (name.equals("HIVE_METASTORE")) {
Assert.assertEquals(0,component.getDependencies().size());
AutoDeployInfo autoDeploy=component.getAutoDeploy();
Assert.assertTrue(autoDeploy.isEnabled());
Assert.assertEquals("HIVE/HIVE_SERVER",autoDeploy.getCoLocate());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("HIVE_SERVER")) {
List dependencyList=component.getDependencies();
Assert.assertEquals(1,dependencyList.size());
DependencyInfo dependency=dependencyList.get(0);
Assert.assertEquals("ZOOKEEPER/ZOOKEEPER_SERVER",dependency.getName());
Assert.assertEquals("cluster",dependency.getScope());
AutoDeployInfo autoDeploy=dependency.getAutoDeploy();
Assert.assertTrue(autoDeploy.isEnabled());
Assert.assertEquals("HIVE/HIVE_SERVER",autoDeploy.getCoLocate());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("MYSQL_SERVER")) {
Assert.assertEquals(0,component.getDependencies().size());
AutoDeployInfo autoDeploy=component.getAutoDeploy();
Assert.assertTrue(autoDeploy.isEnabled());
Assert.assertEquals("HIVE/HIVE_SERVER",autoDeploy.getCoLocate());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("HIVE_CLIENT")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("0+",component.getCardinality());
}
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier definitions=dao.findAll(clusterId);
assertEquals(9,definitions.size());
int hostAlertCount=0;
for ( AlertDefinitionEntity definition : definitions) {
if (definition.getServiceName().equals("AMBARI") && definition.getComponentName().equals("AMBARI_AGENT")) {
hostAlertCount++;
}
}
assertEquals(1,hostAlertCount);
assertEquals(8,definitions.size() - hostAlertCount);
for ( AlertDefinitionEntity definition : definitions) {
definition.setScheduleInterval(28);
dao.merge(definition);
}
metaInfo.reconcileAlertDefinitions(clusters);
definitions=dao.findAll();
assertEquals(9,definitions.size());
for ( AlertDefinitionEntity definition : definitions) {
assertEquals(28,definition.getScheduleInterval().intValue());
}
definitions=dao.findAllEnabled(cluster.getClusterId());
assertEquals(8,definitions.size());
AlertDefinitionEntity entity=new AlertDefinitionEntity();
entity.setClusterId(clusterId);
entity.setDefinitionName("bad_hdfs_alert");
entity.setLabel("Bad HDFS Alert");
entity.setDescription("A way to fake a component being removed");
entity.setEnabled(true);
entity.setHash(UUID.randomUUID().toString());
entity.setScheduleInterval(1);
entity.setServiceName("HDFS");
entity.setComponentName("BAD_COMPONENT");
entity.setSourceType(SourceType.METRIC);
entity.setSource("{\"type\" : \"METRIC\"}");
dao.create(entity);
definitions=dao.findAllEnabled(cluster.getClusterId());
assertEquals(9,definitions.size());
metaInfo.reconcileAlertDefinitions(clusters);
definitions=dao.findAllEnabled(cluster.getClusterId());
assertEquals(8,definitions.size());
definitions=dao.findAll();
assertEquals(10,definitions.size());
entity=dao.findById(entity.getDefinitionId());
assertFalse(entity.getEnabled());
}
BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > repos=metaInfo.getRepository(STACK_NAME_HDP,STACK_VERSION_HDP);
Set centos5Cnt=new HashSet();
Set centos6Cnt=new HashSet();
Set redhat6cnt=new HashSet();
Set redhat5cnt=new HashSet();
for ( List vals : repos.values()) {
for ( RepositoryInfo repo : vals) {
LOG.debug("Dumping repo info : " + repo.toString());
if (repo.getOsType().equals("centos5")) {
centos5Cnt.add(repo.getRepoId());
}
else if (repo.getOsType().equals("centos6")) {
centos6Cnt.add(repo.getRepoId());
}
else if (repo.getOsType().equals("redhat6")) {
redhat6cnt.add(repo.getRepoId());
}
else if (repo.getOsType().equals("redhat5")) {
redhat5cnt.add(repo.getRepoId());
}
else {
fail("Found invalid os " + repo.getOsType());
}
if (repo.getRepoId().equals("epel")) {
assertFalse(repo.getMirrorsList().isEmpty());
assertNull(repo.getBaseUrl());
}
else {
assertNull(repo.getMirrorsList());
assertFalse(repo.getBaseUrl().isEmpty());
}
}
}
assertEquals(3,centos5Cnt.size());
assertEquals(3,redhat6cnt.size());
assertEquals(3,redhat5cnt.size());
assertEquals(3,centos6Cnt.size());
}
InternalCallVerifier EqualityVerifier properties=metaInfo.getPropertiesByName(STACK_NAME_HDP,STACK_VERSION_HDP,SERVICE_NAME_HDFS,PROPERTY_NAME);
Assert.assertEquals(1,properties.size());
for ( PropertyInfo propertyInfo : properties) {
Assert.assertEquals(PROPERTY_NAME,propertyInfo.getName());
Assert.assertEquals(FILE_NAME,propertyInfo.getFilename());
}
try {
metaInfo.getPropertiesByName(STACK_NAME_HDP,STACK_VERSION_HDP,SERVICE_NAME_HDFS,NON_EXT_VALUE);
}
catch ( StackAccessException e) {
}
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier list=metaInfo.getMetrics(STACK_NAME_HDP,"2.0.5","HDFS",SERVICE_COMPONENT_NAME,Resource.Type.Component.name());
Assert.assertNotNull(list);
list=metaInfo.getMetrics(STACK_NAME_HDP,"2.0.5","HDFS","DATANODE",Resource.Type.Component.name());
Assert.assertNull(list);
List list0=metaInfo.getMetrics(STACK_NAME_HDP,"2.0.5","HDFS","DATANODE",Resource.Type.Component.name());
Assert.assertNull(list0);
Assert.assertTrue("Expecting subsequent calls to use a cached value for the definition",list == list0);
list=metaInfo.getMetrics(STACK_NAME_HDP,"2.0.6","HDFS","DATANODE",Resource.Type.Component.name());
Assert.assertNull(list);
}
InternalCallVerifier EqualityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier propertyInfoList=service.getProperties();
Assert.assertNotNull(propertyInfoList);
PropertyInfo passwordProperty=null;
for ( PropertyInfo propertyInfo : propertyInfoList) {
if (propertyInfo.isRequireInput() && propertyInfo.getPropertyTypes().contains(PropertyInfo.PropertyType.PASSWORD)) {
passwordProperty=propertyInfo;
}
else {
Assert.assertTrue(propertyInfo.getPropertyTypes().isEmpty());
}
}
Assert.assertNotNull(passwordProperty);
Assert.assertEquals("javax.jdo.option.ConnectionPassword",passwordProperty.getName());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier components=metaInfo.getComponentsByService(STACK_NAME_HDP,STACK_VERSION_HDP,SERVICE_NAME_HDFS);
assertNotNull(components);
assertTrue(components.size() > 0);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier properties=metaInfo.getPropertiesByName(STACK_NAME_HDP,STACK_VERSION_HDP_02,SERVICE_NAME_HDFS,SHARED_PROPERTY_NAME);
Assert.assertEquals(2,properties.size());
for ( PropertyInfo propertyInfo : properties) {
Assert.assertEquals(SHARED_PROPERTY_NAME,propertyInfo.getName());
Assert.assertTrue(propertyInfo.getFilename().equals(HADOOP_ENV_FILE_NAME) || propertyInfo.getFilename().equals(HDFS_LOG4J_FILE_NAME));
}
}
InternalCallVerifier EqualityVerifier properties=metaInfo.getServiceProperties(STACK_NAME_HDP,STACK_VERSION_HDP,SERVICE_NAME_HDFS);
Assert.assertEquals(properties.size(),PROPERTIES_CNT);
}
InternalCallVerifier EqualityVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(3,componentList.size());
for ( ComponentInfo component : componentList) {
String name=component.getName();
if (name.equals("HBASE_MASTER")) {
List dependencyList=component.getDependencies();
Assert.assertEquals(2,dependencyList.size());
for ( DependencyInfo dependency : dependencyList) {
if (dependency.getName().equals("HDFS/HDFS_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else if (dependency.getName().equals("ZOOKEEPER/ZOOKEEPER_SERVER")) {
Assert.assertEquals("cluster",dependency.getScope());
AutoDeployInfo autoDeploy=dependency.getAutoDeploy();
Assert.assertEquals(true,autoDeploy.isEnabled());
Assert.assertEquals("HBASE/HBASE_MASTER",autoDeploy.getCoLocate());
}
else {
Assert.fail("Unexpected dependency");
}
}
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("HBASE_REGIONSERVER")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1+",component.getCardinality());
}
if (name.equals("HBASE_CLIENT")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("0+",component.getCardinality());
}
}
}
InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier properties=metaInfo.getServiceProperties(STACK_NAME_HDP,STACK_VERSION_HDP_02,SERVICE_NAME_HDFS);
Assert.assertEquals(103,properties.size());
}
APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(1,componentList.size());
ComponentInfo component=componentList.get(0);
Assert.assertEquals("SQOOP",component.getName());
List dependencyList=component.getDependencies();
Assert.assertEquals(2,dependencyList.size());
for ( DependencyInfo dependency : dependencyList) {
if (dependency.getName().equals("HDFS/HDFS_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else if (dependency.getName().equals("MAPREDUCE/MAPREDUCE_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else {
Assert.fail("Unexpected dependency");
}
}
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("0+",component.getCardinality());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(1,componentList.size());
ComponentInfo component=componentList.get(0);
Assert.assertEquals("PIG",component.getName());
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("0+",component.getCardinality());
}
InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier operatingSystems=metaInfo.getOperatingSystems(STACK_NAME_HDP,STACK_VERSION_HDP);
Assert.assertEquals(OS_CNT,operatingSystems.size());
}
APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(1,componentList.size());
ComponentInfo component=componentList.get(0);
Assert.assertEquals("WEBHCAT_SERVER",component.getName());
List dependencyList=component.getDependencies();
Assert.assertEquals(4,dependencyList.size());
for ( DependencyInfo dependency : dependencyList) {
if (dependency.getName().equals("HDFS/HDFS_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else if (dependency.getName().equals("MAPREDUCE/MAPREDUCE_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else if (dependency.getName().equals("ZOOKEEPER/ZOOKEEPER_SERVER")) {
Assert.assertEquals("cluster",dependency.getScope());
AutoDeployInfo autoDeploy=dependency.getAutoDeploy();
Assert.assertEquals(true,autoDeploy.isEnabled());
Assert.assertEquals("WEBHCAT/WEBHCAT_SERVER",autoDeploy.getCoLocate());
}
else if (dependency.getName().equals("ZOOKEEPER/ZOOKEEPER_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else {
Assert.fail("Unexpected dependency");
}
}
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier > repository=metaInfo.getRepository(STACK_NAME_HDP,STACK_VERSION_HDP);
assertNotNull(repository);
assertFalse(repository.get("centos5").isEmpty());
assertFalse(repository.get("centos6").isEmpty());
}
InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier serviceInfos=stackInfo.getServices();
Assert.assertFalse(serviceInfos.isEmpty());
Assert.assertTrue(serviceInfos.size() > 1);
ServiceInfo deletedService=null;
ServiceInfo redefinedService=null;
for ( ServiceInfo serviceInfo : serviceInfos) {
if (serviceInfo.getName().equals("SQOOP")) {
deletedService=serviceInfo;
}
if (serviceInfo.getName().equals("YARN")) {
redefinedService=serviceInfo;
}
}
Assert.assertNull("SQOOP is a deleted service, should not be a part of " + "the extended stack.",deletedService);
Assert.assertNotNull(redefinedService);
Assert.assertEquals("YARN service is expected to be defined with 3 active" + " components.",3,redefinedService.getComponents().size());
Assert.assertEquals("TEZ is expected to be a part of extended stack " + "definition","TEZ",redefinedService.getClientComponent().getName());
Assert.assertFalse("YARN CLIENT is a deleted component.",redefinedService.getClientComponent().getName().equals("YARN_CLIENT"));
Assert.assertNotNull(redefinedService.getProperties());
Assert.assertTrue(redefinedService.getProperties().size() > 4);
PropertyInfo deleteProperty1=null;
PropertyInfo deleteProperty2=null;
PropertyInfo redefinedProperty1=null;
PropertyInfo redefinedProperty2=null;
PropertyInfo redefinedProperty3=null;
PropertyInfo inheritedProperty=null;
PropertyInfo newProperty=null;
PropertyInfo newEnhancedProperty=null;
PropertyInfo propertyWithExtraValueAttributes=null;
PropertyInfo originalProperty=null;
PropertyDependencyInfo propertyDependencyInfo=new PropertyDependencyInfo("yarn-site","new-enhanced-yarn-property");
for ( PropertyInfo propertyInfo : redefinedService.getProperties()) {
if (propertyInfo.getName().equals("yarn.resourcemanager.resource-tracker.address")) {
deleteProperty1=propertyInfo;
}
else if (propertyInfo.getName().equals("yarn.resourcemanager.scheduler.address")) {
deleteProperty2=propertyInfo;
}
else if (propertyInfo.getName().equals("yarn.resourcemanager.address")) {
redefinedProperty1=propertyInfo;
}
else if (propertyInfo.getName().equals("yarn.resourcemanager.admin.address")) {
redefinedProperty2=propertyInfo;
}
else if (propertyInfo.getName().equals("yarn.nodemanager.health-checker.interval-ms")) {
redefinedProperty3=propertyInfo;
}
else if (propertyInfo.getName().equals("yarn.nodemanager.address")) {
inheritedProperty=propertyInfo;
}
else if (propertyInfo.getName().equals("new-yarn-property")) {
newProperty=propertyInfo;
}
else if (propertyInfo.getName().equals("new-enhanced-yarn-property")) {
newEnhancedProperty=propertyInfo;
}
else if (propertyInfo.getName().equals("yarn.nodemanager.aux-services")) {
originalProperty=propertyInfo;
}
else if (propertyInfo.getName().equals("property.with.extra.value.attributes")) {
propertyWithExtraValueAttributes=propertyInfo;
}
}
Assert.assertNull(deleteProperty1);
Assert.assertNull(deleteProperty2);
Assert.assertNotNull(redefinedProperty1);
Assert.assertNotNull(redefinedProperty2);
Assert.assertNotNull("yarn.nodemanager.address expected to be inherited " + "from parent",inheritedProperty);
Assert.assertEquals("localhost:100009",redefinedProperty1.getValue());
Assert.assertNotNull(redefinedProperty3);
Assert.assertEquals("135000",redefinedProperty3.getValue());
Assert.assertEquals("",redefinedProperty2.getValue());
Assert.assertNotNull(newProperty);
Assert.assertEquals("some-value",newProperty.getValue());
Assert.assertEquals("some description.",newProperty.getDescription());
Assert.assertEquals("yarn-site.xml",newProperty.getFilename());
Assert.assertEquals(1,newProperty.getDependedByProperties().size());
Assert.assertTrue(newProperty.getDependedByProperties().contains(propertyDependencyInfo));
Assert.assertNotNull(newEnhancedProperty);
Assert.assertEquals("1024",newEnhancedProperty.getValue());
Assert.assertEquals("some enhanced description.",newEnhancedProperty.getDescription());
Assert.assertEquals("yarn-site.xml",newEnhancedProperty.getFilename());
Assert.assertEquals(2,newEnhancedProperty.getDependsOnProperties().size());
Assert.assertTrue(newEnhancedProperty.getDependsOnProperties().contains(new PropertyDependencyInfo("yarn-site","new-yarn-property")));
Assert.assertTrue(newEnhancedProperty.getDependsOnProperties().contains(new PropertyDependencyInfo("global","yarn_heapsize")));
Assert.assertEquals("MB",newEnhancedProperty.getPropertyValueAttributes().getUnit());
Assert.assertEquals("int",newEnhancedProperty.getPropertyValueAttributes().getType());
Assert.assertEquals("512",newEnhancedProperty.getPropertyValueAttributes().getMinimum());
Assert.assertEquals("15360",newEnhancedProperty.getPropertyValueAttributes().getMaximum());
Assert.assertEquals("256",newEnhancedProperty.getPropertyValueAttributes().getIncrementStep());
Assert.assertNull(newEnhancedProperty.getPropertyValueAttributes().getEntries());
Assert.assertNull(newEnhancedProperty.getPropertyValueAttributes().getEntriesEditable());
Assert.assertTrue(propertyWithExtraValueAttributes.getPropertyValueAttributes().getEmptyValueValid());
Assert.assertTrue(propertyWithExtraValueAttributes.getPropertyValueAttributes().getVisible());
Assert.assertTrue(propertyWithExtraValueAttributes.getPropertyValueAttributes().getReadOnly());
Assert.assertEquals(Boolean.FALSE,propertyWithExtraValueAttributes.getPropertyValueAttributes().getEditableOnlyAtInstall());
Assert.assertEquals(Boolean.FALSE,propertyWithExtraValueAttributes.getPropertyValueAttributes().getOverridable());
Assert.assertEquals(Boolean.FALSE,propertyWithExtraValueAttributes.getPropertyValueAttributes().getShowPropertyName());
Assert.assertNotNull(originalProperty);
Assert.assertEquals("mapreduce.shuffle",originalProperty.getValue());
Assert.assertEquals("Auxilliary services of NodeManager",originalProperty.getDescription());
Assert.assertEquals(6,redefinedService.getConfigDependencies().size());
Assert.assertEquals(7,redefinedService.getConfigDependenciesWithComponents().size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(1,componentList.size());
ComponentInfo component=componentList.get(0);
Assert.assertEquals("HUE_SERVER",component.getName());
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier dependencies=metaInfo.getComponentDependencies("HDP","1.3.4","HBASE","HBASE_MASTER");
assertEquals(2,dependencies.size());
DependencyInfo dependency=dependencies.get(0);
assertEquals("HDFS/HDFS_CLIENT",dependency.getName());
assertEquals("HDFS_CLIENT",dependency.getComponentName());
assertEquals("HDFS",dependency.getServiceName());
assertEquals("host",dependency.getScope());
dependency=dependencies.get(1);
assertEquals("ZOOKEEPER/ZOOKEEPER_SERVER",dependency.getName());
assertEquals("ZOOKEEPER_SERVER",dependency.getComponentName());
assertEquals("ZOOKEEPER",dependency.getServiceName());
assertEquals("cluster",dependency.getScope());
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier redhat6Repo=ambariMetaInfo.getRepositories(STACK_NAME_HDP,"2.1.1","redhat6");
assertNotNull(redhat6Repo);
for ( RepositoryInfo ri : redhat6Repo) {
if (STACK_NAME_HDP.equals(ri.getRepoName())) {
assertEquals(ri.getBaseUrl(),ri.getDefaultBaseUrl());
}
}
}
InternalCallVerifier EqualityVerifier res=metaInfo.getRackSensitiveServicesNames(STACK_NAME_HDP,"2.0.7");
assertEquals(1,res.size());
assertEquals("HDFS",res.iterator().next());
}
InternalCallVerifier EqualityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(2,componentList.size());
for ( ComponentInfo component : componentList) {
String name=component.getName();
if (name.equals("GANGLIA_SERVER")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("GANGLIA_MONITOR")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertTrue(component.getAutoDeploy().isEnabled());
Assert.assertEquals("ALL",component.getCardinality());
}
}
}
InternalCallVerifier EqualityVerifier repositories=metaInfo.getRepositories(STACK_NAME_HDP,STACK_VERSION_HDP,OS_TYPE);
Assert.assertEquals(repositories.size(),REPOS_CNT);
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier redhat6Repo=ambariMetaInfo.getRepositories(STACK_NAME_HDP,stackVersion,"redhat6");
assertNotNull(redhat6Repo);
for ( RepositoryInfo ri : redhat6Repo) {
if (HDP_UTILS_REPO_NAME.equals(ri.getRepoName())) {
assertEquals(newBaseUrl,ri.getBaseUrl());
assertFalse(ri.getBaseUrl().equals(ri.getDefaultBaseUrl()));
}
}
ambariMetaInfo.updateRepoBaseURL(STACK_NAME_HDP,stackVersion,"redhat6",REPO_ID,prevBaseUrl);
}
BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(2,componentList.size());
for ( ComponentInfo component : componentList) {
String name=component.getName();
if (name.equals("ZOOKEEPER_SERVER")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("ZOOKEEPER_CLIENT")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("0+",component.getCardinality());
}
}
}
InternalCallVerifier EqualityVerifier res=metaInfo.getRestartRequiredServicesNames(STACK_NAME_HDP,"2.0.7");
assertEquals(1,res.size());
}
BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(4,componentList.size());
for ( ComponentInfo component : componentList) {
String name=component.getName();
if (name.equals("JOBTRACKER")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("TASKTRACKER")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1+",component.getCardinality());
}
if (name.equals("HISTORYSERVER")) {
Assert.assertEquals(0,component.getDependencies().size());
AutoDeployInfo autoDeploy=component.getAutoDeploy();
Assert.assertTrue(autoDeploy.isEnabled());
Assert.assertEquals("MAPREDUCE/JOBTRACKER",autoDeploy.getCoLocate());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("MAPREDUCE_CLIENT")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("0+",component.getCardinality());
}
}
}
BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(2,componentList.size());
for ( ComponentInfo component : componentList) {
String name=component.getName();
if (name.equals("OOZIE_SERVER")) {
List dependencyList=component.getDependencies();
Assert.assertEquals(2,dependencyList.size());
for ( DependencyInfo dependency : dependencyList) {
if (dependency.getName().equals("HDFS/HDFS_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else if (dependency.getName().equals("MAPREDUCE/MAPREDUCE_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else {
Assert.fail("Unexpected dependency");
}
}
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("OOZIE_CLIENT")) {
List dependencyList=component.getDependencies();
Assert.assertEquals(2,dependencyList.size());
for ( DependencyInfo dependency : dependencyList) {
if (dependency.getName().equals("HDFS/HDFS_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else if (dependency.getName().equals("MAPREDUCE/MAPREDUCE_CLIENT")) {
Assert.assertEquals("host",dependency.getScope());
Assert.assertEquals(true,dependency.getAutoDeploy().isEnabled());
}
else {
Assert.fail("Unexpected dependency");
}
}
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("0+",component.getCardinality());
}
}
}
InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier parents=metaInfo.getStackParentVersions(STACK_NAME_HDP,"2.0.8");
Assert.assertEquals(3,parents.size());
Assert.assertEquals("2.0.7",parents.get(0));
Assert.assertEquals("2.0.6",parents.get(1));
Assert.assertEquals("2.0.5",parents.get(2));
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier redhat6Repo=ambariMetaInfo.getRepositories(STACK_NAME_HDP,"2.1.1","redhat6");
assertNotNull(redhat6Repo);
for ( RepositoryInfo ri : redhat6Repo) {
if (STACK_NAME_HDP.equals(ri.getRepoName())) {
assertEquals(newBaseUrl,ri.getBaseUrl());
assertFalse(ri.getDefaultBaseUrl().equals(ri.getBaseUrl()));
}
}
ambariMetaInfo.updateRepoBaseURL(STACK_NAME_HDP,"2.1.1","redhat6",STACK_NAME_HDP + "-2.1.1",prevBaseUrl);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentList=service.getComponents();
Assert.assertEquals(4,componentList.size());
for ( ComponentInfo component : componentList) {
String name=component.getName();
if (name.equals("NAMENODE")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("DATANODE")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1+",component.getCardinality());
}
if (name.equals("SECONDARY_NAMENODE")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("1",component.getCardinality());
}
if (name.equals("HDFS_CLIENT")) {
Assert.assertEquals(0,component.getDependencies().size());
Assert.assertNull(component.getAutoDeploy());
Assert.assertEquals("0+",component.getCardinality());
}
}
}
BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier list=ambariMetaInfo.getMetrics(stackInfo.getName(),stackInfo.getVersion(),serviceInfo.getName(),componentInfo.getName(),metricType);
String currentComponentInfo=stackInfo.getName() + "-" + stackInfo.getVersion()+ ", "+ serviceInfo.getName()+ ", "+ componentInfo.getName()+ ", "+ metricType;
if (list == null) {
LOG.info("No metrics found for " + currentComponentInfo);
continue;
}
LOG.info("Cross-checking JMX-to-Ganglia metrics for " + currentComponentInfo);
Map jmxMetrics=Collections.emptyMap();
for ( MetricDefinition metricDefinition : list) {
if ("jmx".equals(metricDefinition.getType())) {
jmxMetrics=metricDefinition.getMetrics();
for ( Metric metric : jmxMetrics.values()) {
Assert.assertTrue(metric.isPointInTime());
Assert.assertFalse(metric.isTemporal());
}
}
}
LinkedList failedMetrics=new LinkedList();
for ( MetricDefinition metricDefinition : list) {
if ("ganglia".equals(metricDefinition.getType())) {
for ( Map.Entry metricEntry : metricDefinition.getMetrics().entrySet()) {
Assert.assertTrue(metricEntry.getValue().isTemporal());
if (metricEntry.getValue().isPointInTime() && jmxMetrics.containsKey(metricEntry.getKey())) {
failedMetrics.add(metricEntry.getKey());
}
}
}
}
Assert.assertEquals(failedMetrics.toString() + " metrics defined with pointInTime=true for both jmx and ganglia types.",0,failedMetrics.size());
}
}
}
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier set=metaInfo.getAlertDefinitions(STACK_NAME_HDP,"2.0.5","HDFS");
Assert.assertNotNull(set);
Assert.assertTrue(set.size() > 0);
AlertDefinition nameNodeProcess=null;
AlertDefinition nameNodeCpu=null;
AlertDefinition datanodeStorage=null;
AlertDefinition ignoreHost=null;
Iterator iterator=set.iterator();
while (iterator.hasNext()) {
AlertDefinition definition=iterator.next();
if (definition.getName().equals("namenode_process")) {
nameNodeProcess=definition;
}
if (definition.getName().equals("namenode_cpu")) {
nameNodeCpu=definition;
}
if (definition.getName().equals("datanode_storage")) {
datanodeStorage=definition;
}
if (definition.getName().equals("hdfs_ignore_host_test")) {
ignoreHost=definition;
}
}
assertNotNull(nameNodeProcess);
assertNotNull(nameNodeCpu);
assertNotNull(ignoreHost);
assertEquals("NameNode Host CPU Utilization",nameNodeCpu.getLabel());
assertFalse(nameNodeProcess.isHostIgnored());
assertEquals("A description of namenode_process",nameNodeProcess.getDescription());
Source source=nameNodeProcess.getSource();
assertNotNull(source);
assertNotNull(((PortSource)source).getPort());
Reporting reporting=source.getReporting();
assertNotNull(reporting);
assertNotNull(reporting.getOk());
assertNotNull(reporting.getOk().getText());
assertNull(reporting.getOk().getValue());
assertNotNull(reporting.getCritical());
assertNotNull(reporting.getCritical().getText());
assertNull(reporting.getCritical().getValue());
assertNull(reporting.getWarning());
assertFalse(nameNodeCpu.isHostIgnored());
assertEquals("A description of namenode_cpu",nameNodeCpu.getDescription());
source=nameNodeCpu.getSource();
assertNotNull(source);
reporting=source.getReporting();
assertNotNull(reporting);
assertNotNull(reporting.getOk());
assertNotNull(reporting.getOk().getText());
assertNull(reporting.getOk().getValue());
assertNotNull(reporting.getCritical());
assertNotNull(reporting.getCritical().getText());
assertNotNull(reporting.getCritical().getValue());
assertNotNull(reporting.getWarning());
assertNotNull(reporting.getWarning().getText());
assertNotNull(reporting.getWarning().getValue());
assertNotNull(datanodeStorage);
assertEquals("A description of datanode_storage",datanodeStorage.getDescription());
assertFalse(datanodeStorage.isHostIgnored());
MetricSource metricSource=(MetricSource)datanodeStorage.getSource();
assertNotNull(metricSource.getUri());
assertNotNull(metricSource.getUri().getHttpsProperty());
assertNotNull(metricSource.getUri().getHttpsPropertyValue());
assertNotNull(metricSource.getUri().getHttpsUri());
assertNotNull(metricSource.getUri().getHttpUri());
assertEquals(12345,metricSource.getUri().getDefaultPort());
assertTrue(ignoreHost.isHostIgnored());
}
BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.api.services.BaseRequestTest APIUtilityVerifier InternalCallVerifier IdentityVerifier NullVerifier HybridVerifier queryParams=createMock(MultivaluedMap.class);
RequestHandler handler=createStrictMock(RequestHandler.class);
Result result=createMock(Result.class);
ResultStatus resultStatus=createMock(ResultStatus.class);
ResultPostProcessor processor=createStrictMock(ResultPostProcessor.class);
RequestBody body=createNiceMock(RequestBody.class);
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Renderer renderer=new DefaultRenderer();
Request request=getTestRequest(null,body,uriInfo,compiler,handler,processor,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn(null);
expect(queryParams.getFirst(QueryLexer.QUERY_FORMAT)).andReturn(null);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getRenderer(null)).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(handler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(true).anyTimes();
replay(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
Result processResult=request.process();
verify(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
assertSame(result,processResult);
assertNull(request.getQueryPredicate());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier queryParams=createMock(MultivaluedMap.class);
RequestHandler handler=createStrictMock(RequestHandler.class);
Result result=createMock(Result.class);
ResultStatus resultStatus=createMock(ResultStatus.class);
ResultPostProcessor processor=createStrictMock(ResultPostProcessor.class);
RequestBody body=createNiceMock(RequestBody.class);
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Renderer renderer=new DefaultRenderer();
Request request=getTestRequest(headers,body,uriInfo,compiler,handler,processor,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn(null);
expect(queryParams.getFirst(QueryLexer.QUERY_FORMAT)).andReturn(null);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getRenderer(null)).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(body.getQueryString()).andReturn(null);
expect(compiler.compile("foo=foo-value&bar=bar-value")).andReturn(predicate);
expect(handler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(false).anyTimes();
processor.process(result);
replay(headers,compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,predicate,body);
Result processResult=request.process();
verify(headers,compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,predicate,body);
assertSame(processResult,result);
assertSame(predicate,request.getQueryPredicate());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier queryParams=createMock(MultivaluedMap.class);
URI uri=new URI(URLEncoder.encode(uriString,"UTF-8"));
PredicateCompiler compiler=createStrictMock(PredicateCompiler.class);
RequestBody body=createNiceMock(RequestBody.class);
Exception exception=new InvalidQueryException("test");
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Renderer renderer=new DefaultRenderer();
Request request=getTestRequest(null,body,uriInfo,compiler,null,null,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn(null);
expect(queryParams.getFirst(QueryLexer.QUERY_FORMAT)).andReturn(null);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getRenderer(null)).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(body.getQueryString()).andReturn("blahblahblah");
expect(compiler.compile("blahblahblah")).andThrow(exception);
replay(compiler,uriInfo,queryParams,resource,resourceDefinition,body);
Result processResult=request.process();
verify(compiler,uriInfo,queryParams,resource,resourceDefinition,body);
assertEquals(400,processResult.getStatus().getStatusCode());
assertTrue(processResult.getStatus().isErrorState());
assertEquals("Unable to compile query predicate: test",processResult.getStatus().getMessage());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier queryParams=createMock(MultivaluedMap.class);
RequestHandler handler=createStrictMock(RequestHandler.class);
Result result=createMock(Result.class);
ResultStatus resultStatus=createMock(ResultStatus.class);
ResultPostProcessor processor=createStrictMock(ResultPostProcessor.class);
RequestBody body=createNiceMock(RequestBody.class);
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Set directives=new HashSet();
directives.add("my_directive");
Renderer renderer=new DefaultRenderer();
Request request=getTestRequest(headers,body,uriInfo,compiler,handler,processor,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn(null);
expect(queryParams.getFirst(QueryLexer.QUERY_FORMAT)).andReturn(null);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getUpdateDirectives()).andReturn(directives).anyTimes();
expect(resourceDefinition.getCreateDirectives()).andReturn(directives).anyTimes();
expect(resourceDefinition.getRenderer(null)).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(body.getQueryString()).andReturn(null);
if (request.getRequestType().equals(Request.Type.POST) || request.getRequestType().equals(Request.Type.PUT)) {
expect(compiler.compile("foo=foo-value&bar=bar-value",directives)).andReturn(predicate);
}
else {
expect(compiler.compile("foo=foo-value&bar=bar-value")).andReturn(predicate);
}
expect(handler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(false).anyTimes();
processor.process(result);
replay(headers,compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,predicate,body);
Result processResult=request.process();
verify(headers,compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,predicate,body);
assertSame(processResult,result);
assertSame(predicate,request.getQueryPredicate());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier queryParams=createMock(MultivaluedMap.class);
PredicateCompiler compiler=createStrictMock(PredicateCompiler.class);
Predicate predicate=createNiceMock(Predicate.class);
UriInfo uriInfo=createMock(UriInfo.class);
RequestHandler handler=createStrictMock(RequestHandler.class);
Result result=createMock(Result.class);
ResultStatus resultStatus=createMock(ResultStatus.class);
ResultPostProcessor processor=createStrictMock(ResultPostProcessor.class);
RequestBody body=createNiceMock(RequestBody.class);
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Renderer renderer=new DefaultRenderer();
Request request=getTestRequest(headers,body,uriInfo,compiler,handler,processor,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn(null);
expect(queryParams.getFirst(QueryLexer.QUERY_FORMAT)).andReturn(null);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getRenderer(null)).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(body.getQueryString()).andReturn("foo=bar");
expect(compiler.compile("foo=bar")).andReturn(predicate);
expect(handler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(false).anyTimes();
processor.process(result);
replay(headers,compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,predicate,body);
Result processResult=request.process();
verify(headers,compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,predicate,body);
assertSame(processResult,result);
assertSame(predicate,request.getQueryPredicate());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier queryParams=createMock(MultivaluedMap.class);
RequestHandler handler=createStrictMock(RequestHandler.class);
Result result=createMock(Result.class);
ResultStatus resultStatus=createMock(ResultStatus.class);
ResultPostProcessor processor=createStrictMock(ResultPostProcessor.class);
RequestBody body=createNiceMock(RequestBody.class);
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Renderer renderer=new DefaultRenderer();
Request request=getTestRequest(null,body,uriInfo,compiler,handler,processor,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn(null);
expect(queryParams.getFirst(QueryLexer.QUERY_FORMAT)).andReturn("default");
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getRenderer("default")).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(handler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(false).anyTimes();
processor.process(result);
replay(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
request.process();
verify(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
assertSame(renderer,request.getRenderer());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier queryParams=createMock(MultivaluedMap.class);
RequestHandler handler=createStrictMock(RequestHandler.class);
Result result=createMock(Result.class);
ResultStatus resultStatus=createMock(ResultStatus.class);
ResultPostProcessor processor=createStrictMock(ResultPostProcessor.class);
RequestBody body=createNiceMock(RequestBody.class);
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Renderer renderer=new DefaultRenderer();
Request request=getTestRequest(headers,body,uriInfo,compiler,handler,processor,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn(null);
expect(queryParams.getFirst(QueryLexer.QUERY_FORMAT)).andReturn(null);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getRenderer(null)).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(body.getQueryString()).andReturn("foo=bar");
expect(compiler.compile("foo=bar")).andReturn(predicate);
expect(handler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(false).anyTimes();
processor.process(result);
replay(headers,compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,predicate,body);
Result processResult=request.process();
verify(headers,compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,predicate,body);
assertSame(processResult,result);
assertSame(predicate,request.getQueryPredicate());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier queryParams=createMock(MultivaluedMap.class);
RequestHandler handler=createStrictMock(RequestHandler.class);
Result result=createMock(Result.class);
ResultStatus resultStatus=createMock(ResultStatus.class);
ResultPostProcessor processor=createStrictMock(ResultPostProcessor.class);
RequestBody body=createNiceMock(RequestBody.class);
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Renderer renderer=new MinimalRenderer();
Request request=getTestRequest(null,body,uriInfo,compiler,handler,processor,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn("true");
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getRenderer("minimal")).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(handler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(false).anyTimes();
processor.process(result);
replay(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
request.process();
verify(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
assertSame(renderer,request.getRenderer());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier mapQueryParams=createMock(MultivaluedMap.class);
expect(uriInfo.getQueryParameters()).andReturn(mapQueryParams);
expect(mapQueryParams.getFirst("fields")).andReturn(fields);
replay(uriInfo,mapQueryParams);
Request request=getTestRequest(null,null,uriInfo,null,null,null,null);
Map mapFields=request.getFields();
assertEquals(7,mapFields.size());
String prop="prop";
assertTrue(mapFields.containsKey(prop));
assertNull(mapFields.get(prop));
String prop1=PropertyHelper.getPropertyId("category","prop1");
assertTrue(mapFields.containsKey(prop1));
assertNull(mapFields.get(prop1));
String prop2=PropertyHelper.getPropertyId("category2/category3","prop2");
assertTrue(mapFields.containsKey(prop2));
assertEquals(new TemporalInfoImpl(1,2,3),mapFields.get(prop2));
String prop3="prop3";
assertTrue(mapFields.containsKey(prop3));
assertEquals(new TemporalInfoImpl(4,5,6),mapFields.get(prop3));
String category4="category4";
assertTrue(mapFields.containsKey(category4));
assertEquals(new TemporalInfoImpl(7,8,9),mapFields.get(category4));
String subResource=PropertyHelper.getPropertyId("sub-resource","*");
assertTrue(mapFields.containsKey(subResource));
assertEquals(new TemporalInfoImpl(10,11,12),mapFields.get(subResource));
String finalProp="finalProp";
assertTrue(mapFields.containsKey(finalProp));
assertNull(mapFields.get(finalProp));
verify(uriInfo,mapQueryParams);
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier NullVerifier HybridVerifier queryParams=createMock(MultivaluedMap.class);
RequestHandler handler=createStrictMock(RequestHandler.class);
Result result=createMock(Result.class);
ResultStatus resultStatus=createMock(ResultStatus.class);
ResultPostProcessor processor=createStrictMock(ResultPostProcessor.class);
RequestBody body=createNiceMock(RequestBody.class);
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Renderer renderer=new DefaultRenderer();
Request request=getTestRequest(null,body,uriInfo,compiler,handler,processor,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn(null);
expect(queryParams.getFirst(QueryLexer.QUERY_FORMAT)).andReturn(null);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition);
expect(resourceDefinition.getRenderer(null)).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(handler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(false).anyTimes();
processor.process(result);
expect(body.getQueryString()).andReturn(null);
replay(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
Result processResult=request.process();
verify(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
assertSame(result,processResult);
assertNull(request.getQueryPredicate());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier NullVerifier HybridVerifier queryParams=createMock(MultivaluedMap.class);
RequestHandler handler=createStrictMock(RequestHandler.class);
Result result=createMock(Result.class);
ResultStatus resultStatus=createMock(ResultStatus.class);
ResultPostProcessor processor=createStrictMock(ResultPostProcessor.class);
RequestBody body=createNiceMock(RequestBody.class);
ResourceInstance resource=createNiceMock(ResourceInstance.class);
ResourceDefinition resourceDefinition=createNiceMock(ResourceDefinition.class);
Renderer renderer=new DefaultRenderer();
Request request=getTestRequest(null,body,uriInfo,compiler,handler,processor,resource);
expect(uriInfo.getQueryParameters()).andReturn(queryParams).anyTimes();
expect(queryParams.getFirst(QueryLexer.QUERY_MINIMAL)).andReturn(null);
expect(queryParams.getFirst(QueryLexer.QUERY_FORMAT)).andReturn(null);
expect(resource.getResourceDefinition()).andReturn(resourceDefinition);
expect(resourceDefinition.getRenderer(null)).andReturn(renderer);
expect(uriInfo.getRequestUri()).andReturn(uri).anyTimes();
expect(handler.handleRequest(request)).andReturn(result);
expect(result.getStatus()).andReturn(resultStatus).anyTimes();
expect(resultStatus.isErrorState()).andReturn(false).anyTimes();
processor.process(result);
replay(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
Result processResult=request.process();
verify(compiler,uriInfo,handler,queryParams,resource,resourceDefinition,result,resultStatus,processor,body);
assertSame(result,processResult);
assertNull(request.getQueryPredicate());
}
Class: org.apache.ambari.server.api.services.ClusterStackVersionServiceTest InternalCallVerifier NullVerifier Class: org.apache.ambari.server.api.services.NamedPropertySetTest InternalCallVerifier EqualityVerifier mapProps=new HashMap();
mapProps.put("foo","bar");
NamedPropertySet propertySet=new NamedPropertySet("foo",mapProps);
assertEquals("foo",propertySet.getName());
assertEquals(mapProps,propertySet.getProperties());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier mapProps=new HashMap();
mapProps.put("foo","bar");
NamedPropertySet propertySet=new NamedPropertySet("foo",mapProps);
NamedPropertySet propertySet2=new NamedPropertySet("foo",mapProps);
assertEquals(propertySet,propertySet2);
NamedPropertySet propertySet3=new NamedPropertySet("bar",mapProps);
assertFalse(propertySet.equals(propertySet3));
NamedPropertySet propertySet4=new NamedPropertySet("foo",new HashMap());
assertFalse(propertySet.equals(propertySet4));
}
Class: org.apache.ambari.server.api.services.PersistKeyValueImplTest APIUtilityVerifier InternalCallVerifier EqualityVerifier map=impl.getAllKeyValues();
assertEquals(0,map.size());
impl.put("key1","value1");
impl.put("key2","value2");
map=impl.getAllKeyValues();
assertEquals(2,map.size());
assertEquals("value1",impl.getValue("key1"));
assertEquals("value2",impl.getValue("key2"));
assertEquals(map.get("key1"),impl.getValue("key1"));
impl.put("key1","value1-2");
assertEquals("value1-2",impl.getValue("key1"));
assertEquals(2,map.size());
StringBuilder largeValueBuilder=new StringBuilder();
for (int i=0; i < 320; i++) {
largeValueBuilder.append("0123456789");
}
String largeValue=largeValueBuilder.toString();
impl.put("key3",largeValue);
assertEquals(largeValue,impl.getValue("key3"));
}
Class: org.apache.ambari.server.api.services.PersistServiceTest APIUtilityVerifier InternalCallVerifier EqualityVerifier jsonOutput=StageUtils.fromJson(output,Map.class);
String value=jsonOutput.get("xyx");
Assert.assertEquals("t",value);
webResource=client.resource(String.format("http://localhost:%d/persist/xyx",getTestPort()));
output=webResource.get(String.class);
Assert.assertEquals("t",output);
LOG.info("Value for xyx " + output);
}
Class: org.apache.ambari.server.api.services.RequestBodyTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier IdentityVerifier EqualityVerifier HybridVerifier ());
body.addPropertySet(ps);
assertEquals(1,body.getNamedPropertySets().size());
assertSame(ps,body.getNamedPropertySets().iterator().next());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.api.services.RequestFactoryTest InternalCallVerifier EqualityVerifier mapQueryParams=createMock(MultivaluedMap.class);
expect(uriInfo.getQueryParameters()).andReturn(mapQueryParams).anyTimes();
expect(mapQueryParams.entrySet()).andReturn(Collections.>>emptySet()).anyTimes();
expect(body.getQueryString()).andReturn(null);
replay(headers,uriInfo,body,resource,mapQueryParams);
RequestFactory factory=new RequestFactory();
Request request=factory.createRequest(headers,body,uriInfo,Request.Type.POST,resource);
assertEquals(resource,request.getResource());
assertEquals(body,request.getBody());
assertEquals(Request.Type.POST,request.getRequestType());
verify(headers,uriInfo,body,resource,mapQueryParams);
}
InternalCallVerifier EqualityVerifier mapQueryParams=createMock(MultivaluedMap.class);
expect(uriInfo.getQueryParameters()).andReturn(mapQueryParams).anyTimes();
expect(mapQueryParams.entrySet()).andReturn(Collections.>>emptySet()).anyTimes();
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getCreateDirectives()).andReturn(Collections.emptySet());
expect(body.getQueryString()).andReturn("foo=bar");
replay(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
RequestFactory factory=new RequestFactory();
Request request=factory.createRequest(headers,body,uriInfo,Request.Type.POST,resource);
assertEquals(resource,request.getResource());
assertEquals(body,request.getBody());
assertEquals(Request.Type.QUERY_POST,request.getRequestType());
verify(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
}
InternalCallVerifier EqualityVerifier mapQueryParams=createMock(MultivaluedMap.class);
Map> mapProps=new HashMap>();
mapProps.put("foo",Collections.singletonList("bar"));
Map requestInfoMap=new HashMap();
expect(uriInfo.getQueryParameters()).andReturn(mapQueryParams).anyTimes();
expect(mapQueryParams.entrySet()).andReturn(Collections.>>emptySet()).anyTimes();
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getCreateDirectives()).andReturn(Collections.singleton("foo"));
expect(body.getQueryString()).andReturn("foo=bar");
expect(body.getRequestInfoProperties()).andReturn(requestInfoMap).anyTimes();
replay(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
RequestFactory factory=new RequestFactory();
Request request=factory.createRequest(headers,body,uriInfo,Request.Type.POST,resource);
assertEquals(resource,request.getResource());
assertEquals(body,request.getBody());
assertEquals(Request.Type.POST,request.getRequestType());
assertEquals("bar",requestInfoMap.get("foo"));
verify(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
}
InternalCallVerifier EqualityVerifier mapQueryParams=createMock(MultivaluedMap.class);
Map> mapProps=new HashMap>();
mapProps.put("foo",Collections.singletonList("bar"));
Map requestInfoMap=new HashMap();
expect(uriInfo.getQueryParameters()).andReturn(mapQueryParams).anyTimes();
expect(mapQueryParams.entrySet()).andReturn(mapProps.entrySet()).anyTimes();
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getUpdateDirectives()).andReturn(Collections.singleton("foo"));
expect(body.getQueryString()).andReturn(null);
expect(body.getRequestInfoProperties()).andReturn(requestInfoMap).anyTimes();
replay(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
RequestFactory factory=new RequestFactory();
Request request=factory.createRequest(headers,body,uriInfo,Request.Type.PUT,resource);
assertEquals(resource,request.getResource());
assertEquals(body,request.getBody());
assertEquals(Request.Type.PUT,request.getRequestType());
assertEquals("bar",requestInfoMap.get("foo"));
verify(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
}
InternalCallVerifier EqualityVerifier mapQueryParams=createMock(MultivaluedMap.class);
Map> mapProps=new HashMap>();
mapProps.put("foo",Collections.singletonList("bar"));
Map requestInfoMap=new HashMap();
expect(uriInfo.getQueryParameters()).andReturn(mapQueryParams).anyTimes();
expect(mapQueryParams.entrySet()).andReturn(mapProps.entrySet()).anyTimes();
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getCreateDirectives()).andReturn(Collections.singleton("foo"));
expect(body.getQueryString()).andReturn(null);
expect(body.getRequestInfoProperties()).andReturn(requestInfoMap).anyTimes();
replay(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
RequestFactory factory=new RequestFactory();
Request request=factory.createRequest(headers,body,uriInfo,Request.Type.POST,resource);
assertEquals(resource,request.getResource());
assertEquals(body,request.getBody());
assertEquals(Request.Type.POST,request.getRequestType());
assertEquals("bar",requestInfoMap.get("foo"));
verify(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
}
InternalCallVerifier EqualityVerifier mapQueryParams=createMock(MultivaluedMap.class);
Map> mapProps=new HashMap>();
mapProps.put("foo",Collections.singletonList("bar"));
expect(uriInfo.getQueryParameters()).andReturn(mapQueryParams).anyTimes();
expect(mapQueryParams.entrySet()).andReturn(mapProps.entrySet()).anyTimes();
expect(resource.getResourceDefinition()).andReturn(resourceDefinition).anyTimes();
expect(resourceDefinition.getCreateDirectives()).andReturn(Collections.emptySet());
expect(body.getQueryString()).andReturn(null);
replay(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
RequestFactory factory=new RequestFactory();
Request request=factory.createRequest(headers,body,uriInfo,Request.Type.POST,resource);
assertEquals(resource,request.getResource());
assertEquals(body,request.getBody());
assertEquals(Request.Type.QUERY_POST,request.getRequestType());
verify(headers,uriInfo,body,resource,mapQueryParams,resourceDefinition);
}
Class: org.apache.ambari.server.api.services.ViewExternalSubResourceServiceTest UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.api.services.ViewSubResourceServiceTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier tree=result.getResultTree();
TreeNode child=tree.addChild(resource,"resource1");
child.setProperty("href","this is an href");
HashMap mapRootProps=new HashMap();
mapRootProps.put("prop1","value1");
mapRootProps.put("prop2","value2");
HashMap mapCategoryProps=new HashMap();
mapCategoryProps.put("catProp1","catValue1");
mapCategoryProps.put("catProp2","catValue2");
Map> propertyMap=new HashMap>();
propertyMap.put(null,mapRootProps);
propertyMap.put("category",mapCategoryProps);
expect(resource.getPropertiesMap()).andReturn(propertyMap).anyTimes();
expect(resource.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(uriInfo,resource);
ViewInstanceEntity viewInstanceEntity=ViewInstanceEntityTest.getViewInstanceEntity();
Resource.Type type=new Resource.Type("subResource");
ViewSubResourceService service=new ViewSubResourceService(type,viewInstanceEntity);
ResultSerializer serializer=service.getResultSerializer(MediaType.APPLICATION_JSON_TYPE);
Object o=serializer.serialize(result);
assertTrue(o instanceof Map);
Map map=(Map)o;
assertEquals(4,map.size());
assertEquals("value1",map.get("prop1"));
assertEquals("value2",map.get("prop2"));
assertEquals("this is an href",map.get("href"));
Object o2=map.get("category");
assertNotNull(o2);
assertTrue(o2 instanceof Map);
Map subMap=(Map)o2;
assertEquals(2,subMap.size());
assertEquals("catValue1",subMap.get("catProp1"));
assertEquals("catValue2",subMap.get("catProp2"));
verify(uriInfo,resource);
}
InternalCallVerifier EqualityVerifier tree=result.getResultTree();
TreeNode child=tree.addChild(resource,"resource1");
child.setProperty("href","this is an href");
Map mapRootProps=new LinkedHashMap();
mapRootProps.put("prop2","value2");
mapRootProps.put("prop1","value1");
Map mapCategoryProps=new LinkedHashMap();
mapCategoryProps.put("catProp1","catValue1");
mapCategoryProps.put("catProp2","catValue2");
Map> propertyMap=new LinkedHashMap<>();
propertyMap.put(null,mapRootProps);
propertyMap.put("category",mapCategoryProps);
expect(resource.getPropertiesMap()).andReturn(propertyMap).anyTimes();
expect(resource.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(uriInfo,resource);
ViewInstanceEntity viewInstanceEntity=ViewInstanceEntityTest.getViewInstanceEntity();
Resource.Type type=new Resource.Type("subResource");
ViewSubResourceService service=new ViewSubResourceService(type,viewInstanceEntity);
ResultSerializer serializer=service.getResultSerializer(MediaType.TEXT_PLAIN_TYPE);
Object o=serializer.serialize(result);
String expected="{\n" + " \"href\" : \"this is an href\",\n" + " \"prop2\" : \"value2\",\n"+ " \"prop1\" : \"value1\",\n"+ " \"category\" : {\n"+ " \"catProp1\" : \"catValue1\",\n"+ " \"catProp2\" : \"catValue2\"\n"+ " }\n"+ "}";
assertEquals(expected,o.toString().replace("\r",""));
verify(uriInfo,resource);
}
Class: org.apache.ambari.server.api.services.parsers.JsonRequestBodyParserTest InternalCallVerifier EqualityVerifier setProps=body.getNamedPropertySets();
assertEquals(1,setProps.size());
Map mapExpected=new HashMap();
mapExpected.put(PropertyHelper.getPropertyId("Services","service_name"),"HDFS");
mapExpected.put(PropertyHelper.getPropertyId("Services","display_name"),"HDFS");
mapExpected.put(PropertyHelper.getPropertyId("ServiceInfo","cluster_name"),"tbmetrictest");
mapExpected.put(PropertyHelper.getPropertyId("Services","description"),"Apache Hadoop Distributed File System");
mapExpected.put(PropertyHelper.getPropertyId("ServiceInfo","state"),"STARTED");
mapExpected.put(PropertyHelper.getPropertyId("OuterCategory","propName"),"100");
mapExpected.put(PropertyHelper.getPropertyId("OuterCategory/nested1/nested2","innerPropName"),"innerPropValue");
mapExpected.put(PropertyHelper.getPropertyId(null,"topLevelProp"),"value");
assertEquals(mapExpected,setProps.iterator().next().getProperties());
String b=body.getBody();
body=parser.parse(b).iterator().next();
Set setProps2=body.getNamedPropertySets();
assertEquals(mapExpected,setProps2.iterator().next().getProperties());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier setProperties=body.getNamedPropertySets();
assertEquals(1,setProperties.size());
boolean contains1=false;
boolean contains2=false;
boolean contains3=false;
for ( NamedPropertySet ps : setProperties) {
Map mapProps=ps.getProperties();
assertEquals(1,mapProps.size());
Set> set=(Set>)mapProps.get("services");
for ( Map map : set) {
String serviceName=(String)map.get("ServiceInfo/service_name");
if (serviceName.equals("unitTestService1")) {
assertEquals(1,map.size());
contains1=true;
}
else if (serviceName.equals("unitTestService2")) {
assertEquals("prop1Value",map.get("ServiceInfo/property1"));
assertEquals(2,map.size());
contains2=true;
}
else if (serviceName.equals("unitTestService3")) {
assertEquals("prop2Value",map.get("ServiceInfo/Category/property2"));
assertEquals(2,map.size());
contains3=true;
}
else {
fail("Unexpected service name");
}
}
}
assertTrue(contains1);
assertTrue(contains2);
assertTrue(contains3);
String b=body.getBody();
body=parser.parse(b).iterator().next();
Set setProps2=body.getNamedPropertySets();
assertEquals(1,setProps2.size());
assertEquals(setProperties,setProps2);
assertEquals("java.util.LinkedHashSet",body.getNamedPropertySets().iterator().next().getProperties().get("services").getClass().getName());
}
InternalCallVerifier EqualityVerifier setProps=body.getNamedPropertySets();
assertEquals(1,setProps.size());
Map mapExpected=new HashMap();
mapExpected.put(PropertyHelper.getPropertyId("Services","service_name"),"HDFS");
mapExpected.put(PropertyHelper.getPropertyId("Services","display_name"),"HDFS");
mapExpected.put(PropertyHelper.getPropertyId("ServiceInfo","cluster_name"),"tbmetrictest");
mapExpected.put(PropertyHelper.getPropertyId("Services","description"),"Apache Hadoop Distributed File System");
mapExpected.put(PropertyHelper.getPropertyId("ServiceInfo","state"),"STARTED");
mapExpected.put(PropertyHelper.getPropertyId("OuterCategory","propName"),"100");
mapExpected.put(PropertyHelper.getPropertyId("OuterCategory/nested1/nested2","innerPropName"),"innerPropValue");
mapExpected.put(PropertyHelper.getPropertyId(null,"topLevelProp"),"value");
assertEquals(mapExpected,setProps.iterator().next().getProperties());
assertEquals("foo=bar",body.getQueryString());
String b=body.getBody();
body=parser.parse(b).iterator().next();
Set setProps2=body.getNamedPropertySets();
assertEquals(mapExpected,setProps2.iterator().next().getProperties());
}
BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier setProperties=body.getNamedPropertySets();
assertEquals("foo=bar",body.getQueryString());
assertEquals(1,setProperties.size());
boolean contains1=false;
boolean contains2=false;
boolean contains3=false;
for ( NamedPropertySet ps : setProperties) {
assertEquals("",ps.getName());
Map mapProps=ps.getProperties();
for ( Map.Entry entry : mapProps.entrySet()) {
Set> set=(Set>)entry.getValue();
for ( Map map : set) {
String serviceName=(String)map.get("ServiceInfo/service_name");
if (serviceName.equals("unitTestService1")) {
assertEquals(1,map.size());
contains1=true;
}
else if (serviceName.equals("unitTestService2")) {
assertEquals("prop1Value",map.get("ServiceInfo/property1"));
assertEquals(2,map.size());
contains2=true;
}
else if (serviceName.equals("unitTestService3")) {
assertEquals("prop2Value",map.get("ServiceInfo/Category/property2"));
assertEquals(2,map.size());
contains3=true;
}
else {
fail("Unexpected service name");
}
}
}
}
assertTrue(contains1);
assertTrue(contains2);
assertTrue(contains3);
String b=body.getBody();
assertEquals(queryPostJsonWithQuery,b);
body=parser.parse(b).iterator().next();
Set setProps2=body.getNamedPropertySets();
assertEquals(1,setProps2.size());
assertEquals(setProperties,setProps2);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier setProperties=body.getNamedPropertySets();
assertEquals(1,setProperties.size());
boolean contains1=false;
boolean contains2=false;
for ( NamedPropertySet ps : setProperties) {
Map mapProps=ps.getProperties();
for ( Map.Entry entry : mapProps.entrySet()) {
Set> set=(Set>)entry.getValue();
for ( Map map : set) {
String serviceName=(String)map.get("ServiceInfo/service_name");
if (serviceName.equals("unitTestService1")) {
assertEquals("foo",entry.getKey());
assertEquals(1,map.size());
contains1=true;
}
else if (serviceName.equals("unitTestService2")) {
assertEquals("bar",entry.getKey());
assertEquals("prop2Value",map.get("ServiceInfo/Category/property2"));
assertEquals(2,map.size());
contains2=true;
}
else {
fail("Unexpected service name");
}
}
}
}
assertTrue(contains1);
assertTrue(contains2);
String b=body.getBody();
body=parser.parse(b).iterator().next();
Set setProps2=body.getNamedPropertySets();
assertEquals(1,setProps2.size());
assertEquals(setProperties,setProps2);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier setProps=body.getNamedPropertySets();
assertEquals(1,setProps.size());
Map mapExpected=new HashMap();
mapExpected.put(PropertyHelper.getPropertyId("Services","service_name"),"HDFS");
mapExpected.put(PropertyHelper.getPropertyId("Services","display_name"),"HDFS");
mapExpected.put(PropertyHelper.getPropertyId("ServiceInfo","cluster_name"),"tbmetrictest");
mapExpected.put(PropertyHelper.getPropertyId("Services","description"),"Apache Hadoop Distributed File System");
mapExpected.put(PropertyHelper.getPropertyId("ServiceInfo","state"),"STARTED");
mapExpected.put(PropertyHelper.getPropertyId("OuterCategory","propName"),"100");
mapExpected.put(PropertyHelper.getPropertyId("OuterCategory/nested1/nested2","innerPropName"),"innerPropValue");
mapExpected.put(PropertyHelper.getPropertyId(null,"topLevelProp"),"value");
assertEquals(mapExpected,setProps.iterator().next().getProperties());
assertEquals("foo=bar",body.getQueryString());
Map mapRequestInfoProps=body.getRequestInfoProperties();
assertEquals(4,mapRequestInfoProps.size());
assertEquals("val1",mapRequestInfoProps.get("prop1"));
assertEquals("val2",mapRequestInfoProps.get("prop2"));
assertEquals("foo=bar",mapRequestInfoProps.get("query"));
assertEquals(bodyWithRequestInfoProperties,mapRequestInfoProps.get("RAW_REQUEST_BODY"));
String b=body.getBody();
body=parser.parse(b).iterator().next();
Set setProps2=body.getNamedPropertySets();
assertEquals(mapExpected,setProps2.iterator().next().getProperties());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier setProps=body.getNamedPropertySets();
assertEquals(3,setProps.size());
boolean cluster1Matches=false;
boolean cluster2Matches=false;
boolean cluster3Matches=false;
Map mapCluster1=new HashMap();
mapCluster1.put(PropertyHelper.getPropertyId("Clusters","cluster_name"),"unitTestCluster1");
Map mapCluster2=new HashMap();
mapCluster2.put(PropertyHelper.getPropertyId("Clusters","cluster_name"),"unitTestCluster2");
mapCluster2.put(PropertyHelper.getPropertyId("Clusters","property1"),"prop1Value");
Map mapCluster3=new HashMap();
mapCluster3.put(PropertyHelper.getPropertyId("Clusters","cluster_name"),"unitTestCluster3");
mapCluster3.put(PropertyHelper.getPropertyId("Clusters/Category","property2"),null);
for ( NamedPropertySet propertySet : setProps) {
assertEquals("",propertySet.getName());
Map mapProps=propertySet.getProperties();
if (mapProps.equals(mapCluster1)) {
cluster1Matches=true;
}
else if (mapProps.equals(mapCluster2)) {
cluster2Matches=true;
}
else if (mapProps.equals(mapCluster3)) {
cluster3Matches=true;
}
}
assertTrue(cluster1Matches);
assertTrue(cluster2Matches);
assertTrue(cluster3Matches);
String b=body.getBody();
body=parser.parse(b).iterator().next();
Set setProps2=body.getNamedPropertySets();
assertEquals(3,setProps2.size());
assertEquals(setProps,setProps2);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier setProps=body.getNamedPropertySets();
assertEquals(3,setProps.size());
boolean cluster1Matches=false;
boolean cluster2Matches=false;
boolean cluster3Matches=false;
Map mapCluster1=new HashMap();
mapCluster1.put(PropertyHelper.getPropertyId("Clusters","cluster_name"),"unitTestCluster1");
Map mapCluster2=new HashMap();
mapCluster2.put(PropertyHelper.getPropertyId("Clusters","cluster_name"),"unitTestCluster2");
mapCluster2.put(PropertyHelper.getPropertyId("Clusters","property1"),"prop1Value");
Map mapCluster3=new HashMap();
mapCluster3.put(PropertyHelper.getPropertyId("Clusters","cluster_name"),"unitTestCluster3");
mapCluster3.put(PropertyHelper.getPropertyId("Clusters/Category","property2"),"prop2Value");
for ( NamedPropertySet propertySet : setProps) {
Map mapProps=propertySet.getProperties();
if (mapProps.equals(mapCluster1)) {
cluster1Matches=true;
}
else if (mapProps.equals(mapCluster2)) {
cluster2Matches=true;
}
else if (mapProps.equals(mapCluster3)) {
cluster3Matches=true;
}
}
assertTrue(cluster1Matches);
assertTrue(cluster2Matches);
assertTrue(cluster3Matches);
String b=body.getBody();
body=parser.parse(b).iterator().next();
Set setProps2=body.getNamedPropertySets();
assertEquals(3,setProps2.size());
assertEquals(setProps,setProps2);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier bodySet=parser.parse(multiBody);
assertEquals(2,bodySet.size());
for ( RequestBody body : bodySet) {
Set setProps=body.getNamedPropertySets();
assertEquals(1,setProps.size());
Map mapProps=setProps.iterator().next().getProperties();
assertEquals(4,mapProps.size());
assertEquals("global",mapProps.get("Hosts/desired_config/type"));
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier setProps=body.getNamedPropertySets();
assertEquals(1,setProps.size());
String requestBlob=null;
for ( NamedPropertySet ps : setProps) {
assertEquals("",ps.getName());
Map mapProps=ps.getProperties();
for ( Map.Entry entry : mapProps.entrySet()) {
if (entry.getKey().equals(JsonRequestBodyParser.REQUEST_BLOB_TITLE)) {
requestBlob=(String)entry.getValue();
}
}
}
Assert.assertNotNull(requestBlob);
body=parser.parse(requestBlob).iterator().next();
Map mapExpected=new HashMap();
mapExpected.put(PropertyHelper.getPropertyId("Services","service_name"),"HDFS");
mapExpected.put(PropertyHelper.getPropertyId("Services","display_name"),"HDFS");
mapExpected.put(PropertyHelper.getPropertyId("ServiceInfo","cluster_name"),"tbmetrictest");
mapExpected.put(PropertyHelper.getPropertyId("Services","description"),"Apache Hadoop Distributed File System");
mapExpected.put(PropertyHelper.getPropertyId("ServiceInfo","state"),"STARTED");
mapExpected.put(PropertyHelper.getPropertyId("OuterCategory","propName"),"100");
mapExpected.put(PropertyHelper.getPropertyId("OuterCategory/nested1/nested2","innerPropName"),"innerPropValue");
mapExpected.put(PropertyHelper.getPropertyId(null,"topLevelProp"),"value");
Set setProps2=body.getNamedPropertySets();
assertEquals(mapExpected,setProps2.iterator().next().getProperties());
}
Class: org.apache.ambari.server.api.services.serializers.CsvSerializerTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier tree=result.getResultTree();
List> data=new ArrayList>(){
{
add(new TreeMap(){
{
put("property1","value1a");
put("property2","value2a");
put("property3","value3a");
put("property4","value4a");
}
}
);
add(new TreeMap(){
{
put("property1","value1'b");
put("property2","value2'b");
put("property3","value3'b");
put("property4","value4'b");
}
}
);
add(new TreeMap(){
{
put("property1","value1,c");
put("property2","value2,c");
put("property3","value3,c");
put("property4","value4,c");
}
}
);
}
}
;
tree.setName("items");
tree.setProperty("isCollection","true");
addChildResource(tree,"resource",0,data.get(0));
addChildResource(tree,"resource",1,data.get(1));
addChildResource(tree,"resource",2,data.get(2));
replayAll();
Object o=new CsvSerializer().serialize(result).toString().replace("\r","");
verifyAll();
assertNotNull(o);
StringReader reader=new StringReader(o.toString());
CSVParser csvParser=new CSVParser(reader,CSVFormat.DEFAULT);
List records=csvParser.getRecords();
assertNotNull(records);
assertEquals(3,records.size());
int i=0;
for ( CSVRecord record : records) {
TreeMap actualData=data.get(i++);
assertEquals(actualData.size(),record.size());
for ( String item : record) {
assertTrue(actualData.containsValue(item));
}
}
csvParser.close();
}
InternalCallVerifier EqualityVerifier tree=result.getResultTree();
tree.setName("items");
tree.setProperty("isCollection","true");
tree.setProperty(CsvSerializer.PROPERTY_COLUMN_MAP,new HashMap(){
{
put("property1","Property 1");
put("property2","Property 2");
put("property3","Property 3");
put("property4","Property 4");
}
}
);
tree.setProperty(CsvSerializer.PROPERTY_COLUMN_ORDER,Arrays.asList("property1","property2","property3","property4"));
addChildResource(tree,"resource",0,new HashMap(){
{
put("property1","value1a");
put("property2","value2a");
put("property3","value3a");
put("property4","value4a");
}
}
);
addChildResource(tree,"resource",1,new HashMap(){
{
put("property1","value1'b");
put("property2","value2'b");
put("property3","value3'b");
put("property4","value4'b");
}
}
);
addChildResource(tree,"resource",2,new HashMap(){
{
put("property1","value1,c");
put("property2","value2,c");
put("property3","value3,c");
put("property4","value4,c");
}
}
);
replayAll();
Object o=new CsvSerializer().serialize(result).toString().replace("\r","");
String expected="Property 1,Property 2,Property 3,Property 4\n" + "value1a,value2a,value3a,value4a\n" + "value1'b,value2'b,value3'b,value4'b\n"+ "\"value1,c\",\"value2,c\",\"value3,c\",\"value4,c\"\n";
assertEquals(expected,o);
verifyAll();
}
InternalCallVerifier EqualityVerifier tree=result.getResultTree();
tree.setName("items");
tree.setProperty("isCollection","true");
tree.setProperty(CsvSerializer.PROPERTY_COLUMN_MAP,new TreeMap(){
{
put("propertyD","Property D");
put("propertyC","Property C");
put("propertyB","Property B");
put("propertyA","Property A");
}
}
);
List> data=new ArrayList>(){
{
add(new HashMap(){
{
put("propertyD","value1a");
put("propertyC","value2a");
put("propertyB","value3a");
put("propertyA","value4a");
}
}
);
add(new HashMap(){
{
put("propertyD","value1'b");
put("propertyC","value2'b");
put("propertyB","value3'b");
put("propertyA","value4'b");
}
}
);
add(new HashMap(){
{
put("propertyD","value1,c");
put("propertyC","value2,c");
put("propertyB","value3,c");
put("propertyA","value4,c");
}
}
);
}
}
;
addChildResource(tree,"resource",0,data.get(0));
addChildResource(tree,"resource",1,data.get(1));
addChildResource(tree,"resource",2,data.get(2));
replayAll();
Object o=new CsvSerializer().serialize(result).toString().replace("\r","");
verifyAll();
String expected="Property A,Property B,Property C,Property D\n" + "value4a,value3a,value2a,value1a\n" + "value4'b,value3'b,value2'b,value1'b\n"+ "\"value4,c\",\"value3,c\",\"value2,c\",\"value1,c\"\n";
assertEquals(expected,o);
}
Class: org.apache.ambari.server.api.services.serializers.JsonSerializerTest InternalCallVerifier EqualityVerifier tree=result.getResultTree();
TreeNode child=tree.addChild(resource,"resource1");
child.setProperty("href","this is an href");
Map mapRootProps=new LinkedHashMap<>();
mapRootProps.put("prop2","value2");
mapRootProps.put("prop1","value1");
Map mapCategoryProps=new LinkedHashMap();
mapCategoryProps.put("catProp1","catValue1");
mapCategoryProps.put("catProp2","catValue2");
Map> propertyMap=new LinkedHashMap>();
propertyMap.put(null,mapRootProps);
propertyMap.put("category",mapCategoryProps);
expect(resource.getPropertiesMap()).andReturn(propertyMap).anyTimes();
expect(resource.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(uriInfo,resource);
Object o=new JsonSerializer().serialize(result).toString().replace("\r","");
String expected="{\n" + " \"href\" : \"this is an href\",\n" + " \"prop2\" : \"value2\",\n"+ " \"prop1\" : \"value1\",\n"+ " \"category\" : {\n"+ " \"catProp1\" : \"catValue1\",\n"+ " \"catProp2\" : \"catValue2\"\n"+ " }\n"+ "}";
assertEquals(expected,o);
verify(uriInfo,resource);
}
InternalCallVerifier EqualityVerifier tree=result.getResultTree();
TreeNode child=tree.addChild(resource,"resource1");
child.setProperty("href","this is an href");
tree.addChild(resource,"resource2");
Map mapRootProps=new LinkedHashMap();
mapRootProps.put("prop2","value2");
mapRootProps.put("prop1","value1");
Map mapCategoryProps=new LinkedHashMap();
mapCategoryProps.put("catProp1","catValue1");
mapCategoryProps.put("catProp2","catValue2");
Map> propertyMap=new LinkedHashMap>();
propertyMap.put(null,mapRootProps);
propertyMap.put("category",mapCategoryProps);
expect(resource.getPropertiesMap()).andReturn(propertyMap).anyTimes();
expect(resource.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(uriInfo,resource);
Object o=new JsonSerializer().serialize(result).toString().replace("\r","");
String expected="[\n" + " {\n" + " \"href\" : \"this is an href\",\n"+ " \"prop2\" : \"value2\",\n"+ " \"prop1\" : \"value1\",\n"+ " \"category\" : {\n"+ " \"catProp1\" : \"catValue1\",\n"+ " \"catProp2\" : \"catValue2\"\n"+ " }\n"+ " },\n"+ " {\n"+ " \"prop2\" : \"value2\",\n"+ " \"prop1\" : \"value1\",\n"+ " \"category\" : {\n"+ " \"catProp1\" : \"catValue1\",\n"+ " \"catProp2\" : \"catValue2\"\n"+ " }\n"+ " }\n"+ "]";
assertEquals(expected,o);
verify(uriInfo,resource);
}
InternalCallVerifier EqualityVerifier tree=result.getResultTree();
TreeNode resourcesNode=tree.addChild(null,"resources");
resourcesNode.addChild(resource,"resource1");
Map mapRootProps=new LinkedHashMap();
mapRootProps.put("prop2","value2");
mapRootProps.put("prop1","value1");
Map mapCategoryProps=new LinkedHashMap();
mapCategoryProps.put("catProp1","catValue1");
mapCategoryProps.put("catProp2","catValue2");
Map> propertyMap=new LinkedHashMap>();
propertyMap.put(null,mapRootProps);
propertyMap.put("category",mapCategoryProps);
expect(resource.getPropertiesMap()).andReturn(propertyMap).anyTimes();
expect(resource.getType()).andReturn(Resource.Type.Cluster).anyTimes();
replay(uriInfo,resource);
Object o=new JsonSerializer().serialize(result).toString().replace("\r","");
String expected="{\n" + " \"resources\" : [\n" + " {\n"+ " \"prop2\" : \"value2\",\n"+ " \"prop1\" : \"value1\",\n"+ " \"category\" : {\n"+ " \"catProp1\" : \"catValue1\",\n"+ " \"catProp2\" : \"catValue2\"\n"+ " }\n"+ " }\n"+ " ]\n"+ "}";
assertEquals(expected,o);
verify(uriInfo,resource);
}
Class: org.apache.ambari.server.api.services.stackadvisor.StackAdvisorHelperTest APIUtilityVerifier InternalCallVerifier EqualityVerifier command=mock(StackAdvisorCommand.class);
ValidationResponse expected=mock(ValidationResponse.class);
StackAdvisorRequestType requestType=StackAdvisorRequestType.HOST_GROUPS;
StackAdvisorRequest request=StackAdvisorRequestBuilder.forStack("stackName","stackVersion").ofType(requestType).build();
when(command.invoke(request)).thenReturn(expected);
doReturn(command).when(helper).createValidationCommand(requestType);
ValidationResponse response=helper.validate(request);
assertEquals(expected,response);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier command=mock(StackAdvisorCommand.class);
RecommendationResponse expected=mock(RecommendationResponse.class);
StackAdvisorRequestType requestType=StackAdvisorRequestType.HOST_GROUPS;
StackAdvisorRequest request=StackAdvisorRequestBuilder.forStack("stackName","stackVersion").ofType(requestType).build();
when(command.invoke(request)).thenReturn(expected);
doReturn(command).when(helper).createRecommendationCommand(requestType);
RecommendationResponse response=helper.recommend(request);
assertEquals(expected,response);
}
InternalCallVerifier EqualityVerifier command=helper.createRecommendationCommand(requestType);
assertEquals(ConfigurationDependenciesRecommendationCommand.class,command.getClass());
}
InternalCallVerifier EqualityVerifier command=helper.createValidationCommand(requestType);
assertEquals(ConfigurationValidationCommand.class,command.getClass());
}
InternalCallVerifier EqualityVerifier command=helper.createValidationCommand(requestType);
assertEquals(ComponentLayoutValidationCommand.class,command.getClass());
}
InternalCallVerifier EqualityVerifier command=helper.createRecommendationCommand(requestType);
assertEquals(ComponentLayoutRecommendationCommand.class,command.getClass());
}
Class: org.apache.ambari.server.api.services.stackadvisor.commands.ConfigurationRecommendationCommandTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > componentHostGroupMap=new HashMap>();
Set components1=new HashSet();
components1.add("component1");
components1.add("component4");
components1.add("component5");
componentHostGroupMap.put("group1",components1);
Set components2=new HashSet();
components2.add("component2");
components2.add("component3");
componentHostGroupMap.put("group2",components2);
doReturn(componentHostGroupMap).when(request).getHostComponents();
Set hostGroups=command.processHostGroups(request);
assertNotNull(hostGroups);
assertEquals(2,hostGroups.size());
Map hostGroupMap=new HashMap();
for ( RecommendationResponse.HostGroup hostGroup : hostGroups) {
hostGroupMap.put(hostGroup.getName(),hostGroup);
}
RecommendationResponse.HostGroup hostGroup1=hostGroupMap.get("group1");
assertNotNull(hostGroup1);
Set> host1Components=hostGroup1.getComponents();
assertNotNull(host1Components);
assertEquals(3,host1Components.size());
Set componentNames1=new HashSet();
for ( Map host1Component : host1Components) {
assertNotNull(host1Component);
assertEquals(1,host1Component.size());
String componentName=host1Component.get("name");
assertNotNull(componentName);
componentNames1.add(componentName);
}
assertEquals(3,componentNames1.size());
assertTrue(componentNames1.contains("component1"));
assertTrue(componentNames1.contains("component4"));
assertTrue(componentNames1.contains("component5"));
RecommendationResponse.HostGroup hostGroup2=hostGroupMap.get("group2");
assertNotNull(hostGroup2);
Set> host2Components=hostGroup2.getComponents();
assertNotNull(host2Components);
assertEquals(2,host2Components.size());
Set componentNames2=new HashSet();
for ( Map host2Component : host2Components) {
assertNotNull(host2Component);
assertEquals(1,host2Component.size());
String componentName=host2Component.get("name");
assertNotNull(componentName);
componentNames2.add(componentName);
}
assertEquals(2,componentNames2.size());
assertTrue(componentNames2.contains("component2"));
assertTrue(componentNames2.contains("component3"));
}
Class: org.apache.ambari.server.api.services.stackadvisor.commands.StackAdvisorCommandTest APIUtilityVerifier InternalCallVerifier EqualityVerifier command=spy(new TestStackAdvisorCommand(recommendationsDir,stackAdvisorScript,requestId,saRunner,metaInfo));
StackAdvisorRequest request=StackAdvisorRequestBuilder.forStack("stackName","stackVersion").build();
String hostsJSON="{\"hosts\" : \"localhost\"";
String servicesJSON="{\"services\" : \"HDFS\"";
StackAdvisorData data=new StackAdvisorData(hostsJSON,servicesJSON);
doReturn(hostsJSON).when(command).getHostsInformation(request);
doReturn(servicesJSON).when(command).getServicesInformation(request);
doReturn(data).when(command).adjust(any(StackAdvisorData.class),any(StackAdvisorRequest.class));
doAnswer(new Answer(){
public Object answer( InvocationOnMock invocation) throws Throwable {
String resultFilePath=String.format("%s/%s",requestId,command.getResultFileName());
File resultFile=new File(recommendationsDir,resultFilePath);
resultFile.getParentFile().mkdirs();
FileUtils.writeStringToFile(resultFile,testResourceString);
return null;
}
}
).when(saRunner).runScript(any(String.class),any(StackAdvisorCommandType.class),any(File.class));
TestResource result=command.invoke(request);
assertEquals(expected,result.getType());
assertEquals(requestId,result.getId());
}
InternalCallVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier cmd=new TestStackAdvisorCommand(file,"test",1,stackAdvisorRunner,ambariMetaInfo);
ObjectNode objectNode=(ObjectNode)cmd.mapper.readTree("{\"Versions\": " + "{\"stack_name\": \"stack\", \"stack_version\":\"1.0.0\"}}");
doReturn(Arrays.asList("0.9","0.8")).when(ambariMetaInfo).getStackParentVersions("stack","1.0.0");
cmd.populateStackHierarchy(objectNode);
JsonNode stackHierarchy=objectNode.get("Versions").get("stack_hierarchy");
assertNotNull(stackHierarchy);
JsonNode stackName=stackHierarchy.get("stack_name");
assertNotNull(stackName);
assertEquals("stack",stackName.asText());
ArrayNode stackVersions=(ArrayNode)stackHierarchy.get("stack_versions");
assertNotNull(stackVersions);
assertEquals(2,stackVersions.size());
Iterator stackVersionsElements=stackVersions.getElements();
assertEquals("0.9",stackVersionsElements.next().asText());
assertEquals("0.8",stackVersionsElements.next().asText());
}
InternalCallVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier cmd=new TestStackAdvisorCommand(file,"test",1,stackAdvisorRunner,ambariMetaInfo);
ObjectNode objectNode=(ObjectNode)cmd.mapper.readTree("{\"Versions\": " + "{\"stack_name\": \"stack\", \"stack_version\":\"1.0.0\"}}");
Map props=Collections.singletonMap("a","b");
doReturn(props).when(ambariMetaInfo).getAmbariServerProperties();
cmd.populateAmbariServerInfo(objectNode);
JsonNode serverProperties=objectNode.get("ambari-server-properties");
assertNotNull(serverProperties);
assertEquals("b",serverProperties.iterator().next().getTextValue());
}
InternalCallVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier cmd=new TestStackAdvisorCommand(file,"test",1,stackAdvisorRunner,ambariMetaInfo);
ObjectNode objectNode=(ObjectNode)cmd.mapper.readTree("{\"Versions\": " + "{\"stack_name\": \"stack\", \"stack_version\":\"1.0.0\"}}");
doReturn(Collections.emptyList()).when(ambariMetaInfo).getStackParentVersions("stack","1.0.0");
cmd.populateStackHierarchy(objectNode);
JsonNode stackHierarchy=objectNode.get("Versions").get("stack_hierarchy");
assertNotNull(stackHierarchy);
JsonNode stackName=stackHierarchy.get("stack_name");
assertNotNull(stackName);
assertEquals("stack",stackName.asText());
ArrayNode stackVersions=(ArrayNode)stackHierarchy.get("stack_versions");
assertNotNull(stackVersions);
assertEquals(0,stackVersions.size());
}
Class: org.apache.ambari.server.bootstrap.BootStrapResourceTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.bootstrap.BootStrapTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier listHosts=new ArrayList();
listHosts.add("host1");
listHosts.add("host2");
BSHostStatusCollector collector=new BSHostStatusCollector(tmpFolder,listHosts);
collector.run();
List polledHostStatus=collector.getHostStatus();
Assert.assertTrue(polledHostStatus.size() == 2);
Assert.assertEquals(polledHostStatus.get(0).getHostName(),"host1");
Assert.assertEquals(polledHostStatus.get(0).getLog(),"err_log_1");
Assert.assertEquals(polledHostStatus.get(0).getStatus(),"DONE");
Assert.assertEquals(polledHostStatus.get(1).getHostName(),"host2");
Assert.assertEquals(polledHostStatus.get(1).getLog(),"err_log_2");
Assert.assertEquals(polledHostStatus.get(1).getStatus(),"FAILED");
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hosts=new ArrayList();
hosts.add("host1");
hosts.add("host2");
info.setUserRunAs("root");
info.setHosts(hosts);
info.setUser("user");
info.setPassword("passwd");
BSResponse response=impl.runBootStrap(info);
LOG.info("Response id from bootstrap " + response.getRequestId());
BootStrapStatus status=impl.getStatus(response.getRequestId());
LOG.info("Status " + status.getStatus());
int num=0;
while ((status.getStatus() == BSStat.RUNNING) && (num < 50)) {
status=impl.getStatus(response.getRequestId());
Thread.sleep(1000);
num++;
}
Thread.sleep(5000);
LOG.info("Status: log " + status.getLog() + " status="+ status.getStatus());
Assert.assertTrue(status.getLog().contains("host1,host2"));
Assert.assertEquals(BSStat.SUCCESS,status.getStatus());
Assert.assertFalse(new File(bootdir + File.separator + "1"+ File.separator+ "sshKey").exists());
Assert.assertFalse(new File(bootdir + File.separator + "1"+ File.separator+ "host_pass").exists());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hosts=new ArrayList();
hosts.add("host1");
hosts.add("host2");
info.setHosts(hosts);
info.setUser("user");
info.setUserRunAs("root");
info.setPassword("passwd");
BSResponse response=impl.runBootStrap(info);
long requestId=response.getRequestId();
LOG.info("Response id from bootstrap " + requestId);
File requestDir=new File(bootdir,Long.toString(requestId));
int num=0;
while (!requestDir.exists() && num < 500) {
Thread.sleep(100);
num++;
}
if (!requestDir.exists()) {
LOG.warn("RequestDir does not exists");
}
FileUtils.writeStringToFile(new File(requestDir,"host1.done"),"0");
FileUtils.writeStringToFile(new File(requestDir,"host2.done"),"1");
BootStrapStatus status=impl.getStatus(response.getRequestId());
LOG.info("Status " + status.getStatus());
num=0;
while ((status.getStatus() == BSStat.RUNNING) && (num < 500)) {
status=impl.getStatus(response.getRequestId());
Thread.sleep(100);
num++;
}
LOG.info("Status: log " + status.getLog() + " status="+ status.getStatus());
Assert.assertTrue(status.getLog().contains("host1,host2"));
Assert.assertEquals(BSStat.ERROR,status.getStatus());
Assert.assertEquals("DONE",status.getHostsStatus().get(0).getStatus());
Assert.assertEquals("FAILED",status.getHostsStatus().get(1).getStatus());
}
Class: org.apache.ambari.server.checks.AbstractCheckDescriptorTest InternalCallVerifier EqualityVerifier failedOn=new LinkedHashSet();
Assert.assertEquals("",check.formatEntityList(failedOn));
failedOn.add("host1");
Assert.assertEquals("host1",check.formatEntityList(failedOn));
failedOn.add("host2");
Assert.assertEquals("host1 and host2",check.formatEntityList(failedOn));
failedOn.add("host3");
Assert.assertEquals("host1, host2 and host3",check.formatEntityList(failedOn));
check=new TestCheckImpl(PrereqCheckType.CLUSTER);
Assert.assertEquals("host1, host2 and host3",check.formatEntityList(failedOn));
check=new TestCheckImpl(PrereqCheckType.SERVICE);
Assert.assertEquals("host1, host2 and host3",check.formatEntityList(failedOn));
check=new TestCheckImpl(null);
Assert.assertEquals("host1, host2 and host3",check.formatEntityList(failedOn));
}
Class: org.apache.ambari.server.checks.ClientRetryPropertyCheckTest InternalCallVerifier BooleanVerifier services=new HashMap();
Mockito.when(cluster.getServices()).thenReturn(services);
PrereqCheckRequest request=new PrereqCheckRequest("cluster");
request.setRepositoryVersion("2.3.0.0");
Assert.assertFalse(m_check.isApplicable(request));
services.put("HDFS",Mockito.mock(Service.class));
Assert.assertTrue(m_check.isApplicable(request));
services.clear();
services.put("OOZIE",Mockito.mock(Service.class));
Assert.assertTrue(m_check.isApplicable(request));
}
Class: org.apache.ambari.server.checks.ComponentsInstallationCheckTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (){
@Override public Clusters get(){
return clusters;
}
}
;
componentsInstallationCheck.ambariMetaInfo=new Provider(){
@Override public AmbariMetaInfo get(){
return ambariMetaInfo;
}
}
;
final Cluster cluster=Mockito.mock(Cluster.class);
Mockito.when(cluster.getClusterId()).thenReturn(1L);
Mockito.when(cluster.getCurrentStackVersion()).thenReturn(new StackId("HDP","2.2"));
Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
final Service hdfsService=Mockito.mock(Service.class);
final Service tezService=Mockito.mock(Service.class);
final Service amsService=Mockito.mock(Service.class);
Mockito.when(hdfsService.getMaintenanceState()).thenReturn(MaintenanceState.OFF);
Mockito.when(tezService.getMaintenanceState()).thenReturn(MaintenanceState.OFF);
Mockito.when(amsService.getMaintenanceState()).thenReturn(MaintenanceState.OFF);
HashMap clusterServices=new HashMap();
clusterServices.put("HDFS",hdfsService);
clusterServices.put("TEZ",tezService);
clusterServices.put("AMBARI_METRICS",amsService);
Mockito.when(hdfsService.getName()).thenReturn("HDFS");
Mockito.when(tezService.getName()).thenReturn("TEZ");
Mockito.when(amsService.getName()).thenReturn("AMBARI_METRICS");
Mockito.when(hdfsService.isClientOnlyService()).thenReturn(false);
Mockito.when(tezService.isClientOnlyService()).thenReturn(true);
Mockito.when(amsService.isClientOnlyService()).thenReturn(false);
Mockito.when(cluster.getServices()).thenReturn(clusterServices);
Mockito.when(ambariMetaInfo.getComponent(Mockito.anyString(),Mockito.anyString(),Mockito.anyString(),Mockito.anyString())).thenAnswer(new Answer(){
@Override public ComponentInfo answer( InvocationOnMock invocation) throws Throwable {
ComponentInfo anyInfo=Mockito.mock(ComponentInfo.class);
if (invocation.getArguments().length > 3 && "DATANODE".equals(invocation.getArguments()[3])) {
Mockito.when(anyInfo.getCardinality()).thenReturn("1+");
}
else {
Mockito.when(anyInfo.getCardinality()).thenReturn(null);
}
return anyInfo;
}
}
);
Map hdfsComponents=new HashMap();
ServiceComponent nameNode=Mockito.mock(ServiceComponent.class);
Mockito.when(nameNode.getName()).thenReturn("NAMENODE");
Mockito.when(nameNode.isClientComponent()).thenReturn(false);
Mockito.when(nameNode.isVersionAdvertised()).thenReturn(true);
Mockito.when(nameNode.isMasterComponent()).thenReturn(true);
ServiceComponent dataNode=Mockito.mock(ServiceComponent.class);
Mockito.when(dataNode.getName()).thenReturn("DATANODE");
Mockito.when(dataNode.isClientComponent()).thenReturn(false);
Mockito.when(dataNode.isVersionAdvertised()).thenReturn(true);
Mockito.when(dataNode.isMasterComponent()).thenReturn(false);
ServiceComponent zkfc=Mockito.mock(ServiceComponent.class);
Mockito.when(zkfc.getName()).thenReturn("ZKFC");
Mockito.when(zkfc.isClientComponent()).thenReturn(false);
Mockito.when(zkfc.isVersionAdvertised()).thenReturn(false);
Mockito.when(zkfc.isMasterComponent()).thenReturn(false);
hdfsComponents.put("NAMENODE",nameNode);
hdfsComponents.put("DATANODE",dataNode);
hdfsComponents.put("ZKFC",zkfc);
Mockito.when(hdfsService.getServiceComponents()).thenReturn(hdfsComponents);
Map tezComponents=new HashMap();
ServiceComponent tezClient=Mockito.mock(ServiceComponent.class);
Mockito.when(tezClient.getName()).thenReturn("TEZ_CLIENT");
Mockito.when(tezClient.isClientComponent()).thenReturn(true);
Mockito.when(tezClient.isVersionAdvertised()).thenReturn(true);
tezComponents.put("TEZ_CLIENT",tezClient);
Mockito.when(tezService.getServiceComponents()).thenReturn(tezComponents);
Map amsComponents=new HashMap();
ServiceComponent metricsCollector=Mockito.mock(ServiceComponent.class);
Mockito.when(metricsCollector.getName()).thenReturn("METRICS_COLLECTOR");
Mockito.when(metricsCollector.isClientComponent()).thenReturn(false);
Mockito.when(metricsCollector.isVersionAdvertised()).thenReturn(false);
ServiceComponent metricsMonitor=Mockito.mock(ServiceComponent.class);
Mockito.when(metricsMonitor.getName()).thenReturn("METRICS_MONITOR");
Mockito.when(metricsMonitor.isClientComponent()).thenReturn(false);
Mockito.when(metricsMonitor.isVersionAdvertised()).thenReturn(false);
amsComponents.put("METRICS_COLLECTOR",metricsCollector);
amsComponents.put("METRICS_MONITOR",metricsMonitor);
Mockito.when(amsService.getServiceComponents()).thenReturn(amsComponents);
final HostComponentSummary hcsNameNode=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsDataNode1=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsDataNode2=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsDataNode3=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsZKFC=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsTezClient=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsMetricsCollector=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsMetricsMonitor=Mockito.mock(HostComponentSummary.class);
List allHostComponentSummaries=new ArrayList();
allHostComponentSummaries.add(hcsNameNode);
allHostComponentSummaries.add(hcsDataNode1);
allHostComponentSummaries.add(hcsDataNode2);
allHostComponentSummaries.add(hcsDataNode3);
allHostComponentSummaries.add(hcsZKFC);
allHostComponentSummaries.add(hcsTezClient);
allHostComponentSummaries.add(hcsMetricsCollector);
allHostComponentSummaries.add(hcsMetricsMonitor);
final Map hosts=new HashMap();
final Host host1=Mockito.mock(Host.class);
final Host host2=Mockito.mock(Host.class);
final Host host3=Mockito.mock(Host.class);
Mockito.when(host1.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
Mockito.when(host2.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
Mockito.when(host3.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
hosts.put("host1",host1);
hosts.put("host2",host2);
hosts.put("host3",host3);
Mockito.when(hcsNameNode.getHostName()).thenReturn("host1");
Mockito.when(hcsDataNode1.getHostName()).thenReturn("host1");
Mockito.when(hcsDataNode2.getHostName()).thenReturn("host2");
Mockito.when(hcsDataNode3.getHostName()).thenReturn("host3");
Mockito.when(hcsZKFC.getHostName()).thenReturn("host1");
Mockito.when(hcsTezClient.getHostName()).thenReturn("host2");
Mockito.when(hcsMetricsCollector.getHostName()).thenReturn("host3");
Mockito.when(hcsMetricsMonitor.getHostName()).thenReturn("host3");
Mockito.when(HostComponentSummary.getHostComponentSummaries("HDFS","NAMENODE")).thenReturn(Arrays.asList(hcsNameNode));
Mockito.when(HostComponentSummary.getHostComponentSummaries("HDFS","DATANODE")).thenReturn(Arrays.asList(hcsDataNode1,hcsDataNode2,hcsDataNode3));
Mockito.when(HostComponentSummary.getHostComponentSummaries("HDFS","ZKFC")).thenReturn(Arrays.asList(hcsZKFC));
Mockito.when(HostComponentSummary.getHostComponentSummaries("TEZ","TEZ_CLIENT")).thenReturn(Arrays.asList(hcsTezClient));
Mockito.when(HostComponentSummary.getHostComponentSummaries("AMBARI_METRICS","METRICS_COLLECTOR")).thenReturn(Arrays.asList(hcsMetricsCollector));
Mockito.when(HostComponentSummary.getHostComponentSummaries("AMBARI_METRICS","METRICS_MONITOR")).thenReturn(Arrays.asList(hcsMetricsMonitor));
for ( String hostName : hosts.keySet()) {
Mockito.when(clusters.getHost(hostName)).thenReturn(hosts.get(hostName));
}
for ( HostComponentSummary hcs : allHostComponentSummaries) {
Mockito.when(hcs.getDesiredState()).thenReturn(State.INSTALLED);
Mockito.when(hcs.getCurrentState()).thenReturn(State.STARTED);
}
Mockito.when(hcsTezClient.getCurrentState()).thenReturn(State.INSTALLED);
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
componentsInstallationCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
Mockito.when(hcsMetricsCollector.getCurrentState()).thenReturn(State.INSTALL_FAILED);
Mockito.when(hcsMetricsMonitor.getCurrentState()).thenReturn(State.INSTALL_FAILED);
check=new PrerequisiteCheck(null,null);
componentsInstallationCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
Mockito.when(hcsTezClient.getCurrentState()).thenReturn(State.INSTALL_FAILED);
check=new PrerequisiteCheck(null,null);
componentsInstallationCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
Assert.assertTrue(check.getFailReason().indexOf("Service components in INSTALL_FAILED state") > -1);
Mockito.when(tezService.getMaintenanceState()).thenReturn(MaintenanceState.ON);
Mockito.when(hcsTezClient.getCurrentState()).thenReturn(State.INSTALL_FAILED);
check=new PrerequisiteCheck(null,null);
componentsInstallationCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
Mockito.when(tezService.getMaintenanceState()).thenReturn(MaintenanceState.OFF);
Mockito.when(host2.getMaintenanceState(1L)).thenReturn(MaintenanceState.ON);
Mockito.when(hcsTezClient.getCurrentState()).thenReturn(State.INSTALL_FAILED);
check=new PrerequisiteCheck(null,null);
componentsInstallationCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
}
InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.checks.ConfigurationMergeCheckTest InternalCallVerifier EqualityVerifier (){
@Override public RepositoryVersionDAO get(){
return repositoryVersionDAO;
}
}
;
cmc.clustersProvider=new Provider(){
@Override public Clusters get(){
return clusters;
}
}
;
cmc.m_mergeHelper=new ConfigMergeHelper();
Field field=ConfigMergeHelper.class.getDeclaredField("m_clusters");
field.setAccessible(true);
field.set(cmc.m_mergeHelper,cmc.clustersProvider);
final AmbariMetaInfo ami=EasyMock.createMock(AmbariMetaInfo.class);
field=ConfigMergeHelper.class.getDeclaredField("m_ambariMetaInfo");
field.setAccessible(true);
field.set(cmc.m_mergeHelper,new Provider(){
@Override public AmbariMetaInfo get(){
return ami;
}
}
);
PropertyInfo pi10=new PropertyInfo();
pi10.setFilename(CONFIG_FILE);
pi10.setName(CONFIG_PROPERTY);
pi10.setValue("1024");
PropertyInfo pi11=new PropertyInfo();
pi11.setFilename(CONFIG_FILE);
pi11.setName(CONFIG_PROPERTY);
pi11.setValue("1024");
expect(ami.getServiceProperties("HDP","1.0","HDFS")).andReturn(Collections.singleton(pi10)).anyTimes();
expect(ami.getServiceProperties("HDP","1.1","HDFS")).andReturn(Collections.singleton(pi11)).anyTimes();
expect(ami.getStackProperties(anyObject(String.class),anyObject(String.class))).andReturn(Collections.emptySet()).anyTimes();
replay(ami);
PrereqCheckRequest request=new PrereqCheckRequest("cluster");
request.setTargetStackId(stackId_1_0);
request.setRepositoryVersion("1.1");
PrerequisiteCheck check=new PrerequisiteCheck(null,"cluster");
cmc.perform(check,request);
Assert.assertEquals("Expect no warnings",0,check.getFailedOn().size());
check=new PrerequisiteCheck(null,"cluster");
m_configMap.put(CONFIG_PROPERTY,"1025m");
pi11.setValue("1026");
cmc.perform(check,request);
Assert.assertEquals("Expect warning when user-set has changed from new default",1,check.getFailedOn().size());
Assert.assertEquals(1,check.getFailedDetail().size());
ConfigurationMergeCheck.MergeDetail detail=(ConfigurationMergeCheck.MergeDetail)check.getFailedDetail().get(0);
Assert.assertEquals("1025m",detail.current);
Assert.assertEquals("1026m",detail.new_stack_value);
Assert.assertEquals("1025m",detail.result_value);
Assert.assertEquals(CONFIG_TYPE,detail.type);
Assert.assertEquals(CONFIG_PROPERTY,detail.property);
check=new PrerequisiteCheck(null,"cluster");
pi11.setName(CONFIG_PROPERTY + ".foo");
cmc.perform(check,request);
Assert.assertEquals("Expect no warning when user new stack is empty",0,check.getFailedOn().size());
Assert.assertEquals(0,check.getFailedDetail().size());
check=new PrerequisiteCheck(null,"cluster");
pi11.setName(CONFIG_PROPERTY);
pi10.setName(CONFIG_PROPERTY + ".foo");
cmc.perform(check,request);
Assert.assertEquals("Expect warning when user old stack is empty, and value changed",1,check.getFailedOn().size());
Assert.assertEquals(1,check.getFailedDetail().size());
detail=(ConfigurationMergeCheck.MergeDetail)check.getFailedDetail().get(0);
Assert.assertEquals("1025m",detail.current);
Assert.assertEquals("1026m",detail.new_stack_value);
}
InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.checks.HiveDynamicServiceDiscoveryCheckTest InternalCallVerifier EqualityVerifier configMap=new HashMap();
configMap.put("hive-site",desiredConfig);
Mockito.when(cluster.getDesiredConfigs()).thenReturn(configMap);
final Config config=Mockito.mock(Config.class);
Mockito.when(cluster.getConfig(Mockito.anyString(),Mockito.anyString())).thenReturn(config);
final Map properties=new HashMap();
Mockito.when(config.getProperties()).thenReturn(properties);
Map checkProperties=new HashMap();
checkProperties.put("min-failure-stack-version","HDP-2.3.0.0");
PrerequisiteCheckConfig prerequisiteCheckConfig=Mockito.mock(PrerequisiteCheckConfig.class);
Mockito.when(prerequisiteCheckConfig.getCheckProperties(m_check.getClass().getName())).thenReturn(checkProperties);
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
PrereqCheckRequest request=new PrereqCheckRequest("cluster");
request.setPrerequisiteCheckConfig(prerequisiteCheckConfig);
request.setSourceStackId(new StackId("HDP-2.2.4.2"));
request.setTargetStackId(new StackId("HDP-2.2.8.4"));
m_check.perform(check,request);
Assert.assertEquals(PrereqCheckStatus.WARNING,check.getStatus());
request.setSourceStackId(new StackId("HDP-2.2.4.2"));
request.setTargetStackId(new StackId("HDP-2.3.8.4"));
m_check.perform(check,request);
Assert.assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
request.setSourceStackId(new StackId("HDP-2.3.4.2"));
request.setTargetStackId(new StackId("HDP-2.3.8.4"));
m_check.perform(check,request);
Assert.assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
request.setSourceStackId(new StackId("HDP-2.3.4.2"));
request.setTargetStackId(new StackId("HDP-2.4.8.4"));
m_check.perform(check,request);
Assert.assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
properties.put("hive.server2.support.dynamic.service.discovery","true");
properties.put("hive.zookeeper.quorum","host");
properties.put("hive.server2.zookeeper.namespace","namespace");
check=new PrerequisiteCheck(null,null);
m_check.perform(check,request);
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
}
Class: org.apache.ambari.server.checks.HiveMultipleMetastoreCheckTest InternalCallVerifier BooleanVerifier services=new HashMap();
Mockito.when(cluster.getServices()).thenReturn(services);
services.put("HDFS",Mockito.mock(Service.class));
PrereqCheckRequest request=new PrereqCheckRequest("cluster");
request.setRepositoryVersion("2.3.0.0");
Assert.assertFalse(m_check.isApplicable(request));
services.put("HIVE",Mockito.mock(Service.class));
Assert.assertTrue(m_check.isApplicable(request));
}
InternalCallVerifier EqualityVerifier failedOnExpected=new LinkedHashSet();
Service hive=Mockito.mock(Service.class);
ServiceComponent metastore=Mockito.mock(ServiceComponent.class);
Map metastores=new HashMap();
failedOnExpected.add("HIVE");
Mockito.when(cluster.getClusterId()).thenReturn(1L);
Mockito.when(m_clusters.getCluster("cluster")).thenReturn(cluster);
Mockito.when(cluster.getService("HIVE")).thenReturn(hive);
Mockito.when(hive.getServiceComponent("HIVE_METASTORE")).thenReturn(metastore);
Mockito.when(metastore.getServiceComponentHosts()).thenReturn(metastores);
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
PrereqCheckRequest request=new PrereqCheckRequest("cluster");
request.setRepositoryVersion("2.3.0.0");
m_check.perform(check,request);
Assert.assertEquals(PrereqCheckStatus.WARNING,check.getStatus());
check=new PrerequisiteCheck(null,null);
m_check.perform(check,request);
Assert.assertEquals(failedOnExpected,check.getFailedOn());
Assert.assertEquals(PrereqCheckStatus.WARNING,check.getStatus());
}
Class: org.apache.ambari.server.checks.HostsHeartbeatCheckTest InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.checks.HostsMasterMaintenanceCheckTest InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.checks.HostsRepositoryVersionCheckTest InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.checks.InstallPackagesCheckTest InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
@Override public Clusters get(){
return clusters;
}
}
;
installPackagesCheck.ambariMetaInfo=new Provider(){
@Override public AmbariMetaInfo get(){
return ambariMetaInfo;
}
}
;
installPackagesCheck.clusterVersionDAOProvider=new Provider(){
@Override public ClusterVersionDAO get(){
return clusterVersionDAO;
}
}
;
installPackagesCheck.hostVersionDaoProvider=new Provider(){
@Override public HostVersionDAO get(){
return hostVersionDAO;
}
}
;
installPackagesCheck.repositoryVersionDaoProvider=new Provider(){
@Override public RepositoryVersionDAO get(){
return repositoryVersionDAO;
}
}
;
StackEntity stack=new StackEntity();
stack.setStackName(stackId.getStackName());
stack.setStackVersion(stackId.getStackVersion());
RepositoryVersionEntity rve=new RepositoryVersionEntity(stack,repositoryVersion,repositoryVersion,"rhel6");
Mockito.when(repositoryVersionDAO.findByStackNameAndVersion(Mockito.anyString(),Mockito.anyString())).thenReturn(rve);
final Cluster cluster=Mockito.mock(Cluster.class);
Mockito.when(cluster.getClusterName()).thenReturn(clusterName);
Mockito.when(cluster.getClusterId()).thenReturn(1L);
Mockito.when(cluster.getCurrentStackVersion()).thenReturn(stackId);
Mockito.when(clusters.getCluster(clusterName)).thenReturn(cluster);
ClusterVersionEntity clusterVersionEntity=Mockito.mock(ClusterVersionEntity.class);
Mockito.when(clusterVersionEntity.getState()).thenReturn(RepositoryVersionState.INSTALLED);
Mockito.when(clusterVersionDAO.findByClusterAndStackAndVersion(clusterName,targetStackId,repositoryVersion)).thenReturn(clusterVersionEntity);
final List hostNames=new ArrayList();
hostNames.add("host1");
hostNames.add("host2");
hostNames.add("host3");
final List hosts=new ArrayList();
final List hostVersionEntities=new ArrayList();
for ( String hostName : hostNames) {
Host host=Mockito.mock(Host.class);
host.setHostName(hostName);
Mockito.when(host.getHostName()).thenReturn(hostName);
Mockito.when(host.getMaintenanceState(1L)).thenReturn(MaintenanceState.OFF);
hosts.add(host);
HostVersionEntity hve=Mockito.mock(HostVersionEntity.class);
Mockito.when(hve.getRepositoryVersion()).thenReturn(rve);
Mockito.when(hve.getState()).thenReturn(RepositoryVersionState.INSTALLED);
hostVersionEntities.add(hve);
Mockito.when(hostVersionDAO.findByHost(hostName)).thenReturn(Collections.singletonList(hve));
}
Mockito.when(cluster.getHosts()).thenReturn(hosts);
PrereqCheckRequest checkRequest=new PrereqCheckRequest(clusterName);
checkRequest.setRepositoryVersion(repositoryVersion);
checkRequest.setSourceStackId(sourceStackId);
checkRequest.setTargetStackId(targetStackId);
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
installPackagesCheck.perform(check,checkRequest);
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
Mockito.when(hostVersionEntities.get(0).getState()).thenReturn(RepositoryVersionState.INSTALL_FAILED);
Mockito.when(clusterVersionEntity.getState()).thenReturn(RepositoryVersionState.INSTALL_FAILED);
check=new PrerequisiteCheck(null,null);
installPackagesCheck.perform(check,checkRequest);
Assert.assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
Assert.assertNotNull(check.getFailedOn());
Assert.assertTrue(check.getFailedOn().contains("host1"));
Mockito.when(hostVersionEntities.get(0).getState()).thenReturn(RepositoryVersionState.INSTALL_FAILED);
Mockito.when(hosts.get(0).getMaintenanceState(1L)).thenReturn(MaintenanceState.ON);
Mockito.when(clusterVersionEntity.getState()).thenReturn(RepositoryVersionState.INSTALL_FAILED);
check=new PrerequisiteCheck(null,null);
installPackagesCheck.perform(check,checkRequest);
Assert.assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
Assert.assertNotNull(check.getFailedOn());
Assert.assertTrue(check.getFailedOn().contains(clusterName));
}
Class: org.apache.ambari.server.checks.MapReduce2JobHistoryStatePreservingCheckTest InternalCallVerifier BooleanVerifier services=new HashMap();
Mockito.when(cluster.getServices()).thenReturn(services);
ClusterVersionEntity clusterVersionEntity=Mockito.mock(ClusterVersionEntity.class);
Mockito.when(cluster.getCurrentClusterVersion()).thenReturn(clusterVersionEntity);
PrereqCheckRequest request=new PrereqCheckRequest("cluster");
request.setTargetStackId(new StackId("HDP","2.3.1.1"));
request.setSourceStackId(new StackId("HDP","2.3.0.0"));
Assert.assertFalse(m_check.isApplicable(request));
services.put("MAPREDUCE2",Mockito.mock(Service.class));
Assert.assertTrue(m_check.isApplicable(request));
}
InternalCallVerifier BooleanVerifier (){
{
put("MAPREDUCE2",null);
}
}
);
Mockito.when(cluster.getCurrentStackVersion()).thenReturn(new StackId("MYSTACK-12.2"));
ClusterVersionEntity clusterVersionEntity=Mockito.mock(ClusterVersionEntity.class);
Mockito.when(cluster.getCurrentClusterVersion()).thenReturn(clusterVersionEntity);
RepositoryVersionEntity repositoryVersionEntity=Mockito.mock(RepositoryVersionEntity.class);
Mockito.when(clusterVersionEntity.getRepositoryVersion()).thenReturn(repositoryVersionEntity);
Mockito.when(m_clusters.getCluster("c1")).thenReturn(cluster);
PrereqCheckRequest request=new PrereqCheckRequest("c1");
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.0.0.1");
boolean isApplicable=m_check.isApplicable(request);
Assert.assertTrue(isApplicable);
}
Class: org.apache.ambari.server.checks.RangerPasswordCheckTest InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
assertEquals("Credentials for user 'r_admin' in Ambari do not match Ranger.",check.getFailReason());
verify(conn,streamProvider);
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(CheckDescription.SERVICES_RANGER_PASSWORD_VERIFY,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
assertEquals(PrereqCheckStatus.WARNING,check.getStatus());
assertEquals("Could not verify credentials for user 'admin'. Response code 404 received from " + RANGER_URL + "service/public/api/repository/count",check.getFailReason());
verify(conn,streamProvider);
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
assertEquals(PrereqCheckStatus.WARNING,check.getStatus());
assertEquals("Could not verify credentials for user 'r_admin'. Response code 500 received from " + RANGER_URL + "service/public/api/repository/count",check.getFailReason());
verify(conn,streamProvider);
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_configMap.put("ranger_admin_password","r_pass");
check=new PrerequisiteCheck(null,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
assertEquals(PrereqCheckStatus.PASS,check.getStatus());
}
InternalCallVerifier BooleanVerifier services=new HashMap<>();
services.put("RANGER",service);
Cluster cluster=m_clusters.getCluster("cluster");
EasyMock.reset(cluster);
expect(cluster.getServices()).andReturn(services).anyTimes();
expect(cluster.getCurrentStackVersion()).andReturn(new StackId("HDP-2.3")).anyTimes();
replay(cluster);
PrereqCheckRequest request=new PrereqCheckRequest("cluster");
request.setSourceStackId(new StackId("HDP-2.3"));
assertTrue(m_rpc.isApplicable(request));
request=new PrereqCheckRequest("cluster");
request.setSourceStackId(new StackId("HDP-2.2"));
assertFalse(m_rpc.isApplicable(request));
EasyMock.reset(cluster);
expect(cluster.getServices()).andReturn(services).anyTimes();
expect(cluster.getCurrentStackVersion()).andReturn(new StackId("WILDSTACK-2.0")).anyTimes();
replay(cluster);
request=new PrereqCheckRequest("cluster");
request.setSourceStackId(new StackId("HDP-2.2"));
assertTrue(m_rpc.isApplicable(request));
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(CheckDescription.SERVICES_RANGER_PASSWORD_VERIFY,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
assertEquals("Credentials for user 'admin' in Ambari do not match Ranger.",check.getFailReason());
verify(conn,streamProvider);
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
String error="The response from Ranger was malformed. ";
error+="java.lang.String cannot be cast to java.util.List. ";
error+="Request: " + RANGER_URL + "service/xusers/users?name=r_admin";
assertEquals(PrereqCheckStatus.WARNING,check.getStatus());
assertEquals(error,check.getFailReason());
verify(conn,streamProvider);
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
assertEquals("Credentials for user 'r_admin' in Ambari do not match Ranger.",check.getFailReason());
verify(conn,streamProvider);
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
assertEquals(PrereqCheckStatus.WARNING,check.getStatus());
assertEquals("Could not access Ranger to verify user 'r_admin' against " + RANGER_URL + "service/public/api/repository/count. again!",check.getFailReason());
verify(conn,streamProvider);
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
String error="The response from Ranger was malformed. ";
error+="com.google.gson.stream.MalformedJsonException: Expected EOF at line 1 column 6. ";
error+="Request: " + RANGER_URL + "service/xusers/users?name=r_admin";
assertEquals(PrereqCheckStatus.WARNING,check.getStatus());
assertEquals(error,check.getFailReason());
verify(conn,streamProvider);
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(CheckDescription.SERVICES_RANGER_PASSWORD_VERIFY,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
assertEquals(PrereqCheckStatus.WARNING,check.getStatus());
assertEquals("Could not access Ranger to verify user 'admin' against " + RANGER_URL + "service/public/api/repository/count. whoops",check.getFailReason());
verify(conn,streamProvider);
}
InternalCallVerifier EqualityVerifier >)anyObject())).andReturn(conn).anyTimes();
replay(conn,streamProvider);
m_rpc.m_streamProvider=streamProvider;
PrerequisiteCheck check=new PrerequisiteCheck(CheckDescription.SERVICES_RANGER_PASSWORD_VERIFY,null);
m_rpc.perform(check,new PrereqCheckRequest("cluster"));
assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
assertEquals("Credentials for user 'admin' in Ambari do not match Ranger.",check.getFailReason());
verify(conn,streamProvider);
}
Class: org.apache.ambari.server.checks.SecondaryNamenodeDeletedCheckTest InternalCallVerifier BooleanVerifier services=new HashMap<>();
final Service service=Mockito.mock(Service.class);
services.put("HDFS",service);
Mockito.when(cluster.getClusterId()).thenReturn(1L);
Mockito.when(cluster.getServices()).thenReturn(services);
Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
Assert.assertTrue(secondaryNamenodeDeletedCheck.isApplicable(new PrereqCheckRequest("cluster")));
PrereqCheckRequest req=new PrereqCheckRequest("cluster");
req.addResult(CheckDescription.SERVICES_NAMENODE_HA,PrereqCheckStatus.FAIL);
Assert.assertFalse(secondaryNamenodeDeletedCheck.isApplicable(req));
req.addResult(CheckDescription.SERVICES_NAMENODE_HA,PrereqCheckStatus.PASS);
Assert.assertTrue(secondaryNamenodeDeletedCheck.isApplicable(req));
services.remove("HDFS");
Assert.assertFalse(secondaryNamenodeDeletedCheck.isApplicable(new PrereqCheckRequest("cluster")));
}
Class: org.apache.ambari.server.checks.ServicesMaintenanceModeCheckTest InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.checks.ServicesMapReduceDistributedCacheCheckTest InternalCallVerifier BooleanVerifier services=new HashMap<>();
final Service service=Mockito.mock(Service.class);
services.put("YARN",service);
Mockito.when(cluster.getServices()).thenReturn(services);
Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
Mockito.when(cluster.getClusterId()).thenReturn(1L);
Assert.assertTrue(servicesMapReduceDistributedCacheCheck.isApplicable(new PrereqCheckRequest("cluster")));
PrereqCheckRequest req=new PrereqCheckRequest("cluster");
req.addResult(CheckDescription.SERVICES_NAMENODE_HA,PrereqCheckStatus.FAIL);
Assert.assertFalse(servicesMapReduceDistributedCacheCheck.isApplicable(req));
req.addResult(CheckDescription.SERVICES_NAMENODE_HA,PrereqCheckStatus.PASS);
Assert.assertTrue(servicesMapReduceDistributedCacheCheck.isApplicable(req));
services.remove("YARN");
Assert.assertFalse(servicesMapReduceDistributedCacheCheck.isApplicable(new PrereqCheckRequest("cluster")));
}
Class: org.apache.ambari.server.checks.ServicesNamenodeHighAvailabilityCheckTest InternalCallVerifier BooleanVerifier services=new HashMap<>();
final Service service=Mockito.mock(Service.class);
services.put("HDFS",service);
Mockito.when(cluster.getServices()).thenReturn(services);
Mockito.when(cluster.getClusterId()).thenReturn(1L);
Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
Assert.assertTrue(servicesNamenodeHighAvailabilityCheck.isApplicable(new PrereqCheckRequest("cluster")));
services.remove("HDFS");
Assert.assertFalse(servicesNamenodeHighAvailabilityCheck.isApplicable(new PrereqCheckRequest("cluster")));
}
Class: org.apache.ambari.server.checks.ServicesNamenodeTruncateCheckTest InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.checks.ServicesTezDistributedCacheCheckTest InternalCallVerifier BooleanVerifier services=new HashMap<>();
final Service service=Mockito.mock(Service.class);
services.put("TEZ",service);
Mockito.when(cluster.getServices()).thenReturn(services);
Mockito.when(cluster.getClusterId()).thenReturn(1L);
Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
Assert.assertTrue(servicesTezDistributedCacheCheck.isApplicable(new PrereqCheckRequest("cluster")));
PrereqCheckRequest req=new PrereqCheckRequest("cluster");
req.addResult(CheckDescription.SERVICES_NAMENODE_HA,PrereqCheckStatus.FAIL);
Assert.assertFalse(servicesTezDistributedCacheCheck.isApplicable(req));
req.addResult(CheckDescription.SERVICES_NAMENODE_HA,PrereqCheckStatus.PASS);
Assert.assertTrue(servicesTezDistributedCacheCheck.isApplicable(req));
services.remove("TEZ");
Assert.assertFalse(servicesTezDistributedCacheCheck.isApplicable(new PrereqCheckRequest("cluster")));
}
Class: org.apache.ambari.server.checks.ServicesUpCheckTest InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (){
@Override public Clusters get(){
return clusters;
}
}
;
servicesUpCheck.ambariMetaInfo=new Provider(){
@Override public AmbariMetaInfo get(){
return ambariMetaInfo;
}
}
;
final Cluster cluster=Mockito.mock(Cluster.class);
Mockito.when(cluster.getClusterId()).thenReturn(1L);
Mockito.when(cluster.getCurrentStackVersion()).thenReturn(new StackId("HDP","2.2"));
Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
final Service hdfsService=Mockito.mock(Service.class);
final Service tezService=Mockito.mock(Service.class);
final Service amsService=Mockito.mock(Service.class);
HashMap clusterServices=new HashMap();
clusterServices.put("HDFS",hdfsService);
clusterServices.put("TEZ",tezService);
clusterServices.put("AMBARI_METRICS",amsService);
Mockito.when(hdfsService.getName()).thenReturn("HDFS");
Mockito.when(tezService.getName()).thenReturn("TEZ");
Mockito.when(amsService.getName()).thenReturn("AMBARI_METRICS");
Mockito.when(hdfsService.isClientOnlyService()).thenReturn(false);
Mockito.when(tezService.isClientOnlyService()).thenReturn(true);
Mockito.when(amsService.isClientOnlyService()).thenReturn(false);
Mockito.when(cluster.getServices()).thenReturn(clusterServices);
Mockito.when(ambariMetaInfo.getComponent(Mockito.anyString(),Mockito.anyString(),Mockito.anyString(),Mockito.anyString())).thenAnswer(new Answer(){
@Override public ComponentInfo answer( InvocationOnMock invocation) throws Throwable {
ComponentInfo anyInfo=Mockito.mock(ComponentInfo.class);
if (invocation.getArguments().length > 3 && "DATANODE".equals(invocation.getArguments()[3])) {
Mockito.when(anyInfo.getCardinality()).thenReturn("1+");
}
else {
Mockito.when(anyInfo.getCardinality()).thenReturn(null);
}
return anyInfo;
}
}
);
Map hdfsComponents=new HashMap();
ServiceComponent nameNode=Mockito.mock(ServiceComponent.class);
Mockito.when(nameNode.getName()).thenReturn("NAMENODE");
Mockito.when(nameNode.isClientComponent()).thenReturn(false);
Mockito.when(nameNode.isVersionAdvertised()).thenReturn(true);
Mockito.when(nameNode.isMasterComponent()).thenReturn(true);
ServiceComponent dataNode=Mockito.mock(ServiceComponent.class);
Mockito.when(dataNode.getName()).thenReturn("DATANODE");
Mockito.when(dataNode.isClientComponent()).thenReturn(false);
Mockito.when(dataNode.isVersionAdvertised()).thenReturn(true);
Mockito.when(dataNode.isMasterComponent()).thenReturn(false);
ServiceComponent zkfc=Mockito.mock(ServiceComponent.class);
Mockito.when(zkfc.getName()).thenReturn("ZKFC");
Mockito.when(zkfc.isClientComponent()).thenReturn(false);
Mockito.when(zkfc.isVersionAdvertised()).thenReturn(false);
Mockito.when(zkfc.isMasterComponent()).thenReturn(false);
hdfsComponents.put("NAMENODE",nameNode);
hdfsComponents.put("DATANODE",dataNode);
hdfsComponents.put("ZKFC",zkfc);
Mockito.when(hdfsService.getServiceComponents()).thenReturn(hdfsComponents);
Map tezComponents=new HashMap();
ServiceComponent tezClient=Mockito.mock(ServiceComponent.class);
Mockito.when(tezClient.getName()).thenReturn("TEZ_CLIENT");
Mockito.when(tezClient.isClientComponent()).thenReturn(true);
Mockito.when(tezClient.isVersionAdvertised()).thenReturn(true);
tezComponents.put("TEZ_CLIENT",tezClient);
Mockito.when(tezService.getServiceComponents()).thenReturn(tezComponents);
Map amsComponents=new HashMap();
ServiceComponent metricsCollector=Mockito.mock(ServiceComponent.class);
Mockito.when(metricsCollector.getName()).thenReturn("METRICS_COLLECTOR");
Mockito.when(metricsCollector.isClientComponent()).thenReturn(false);
Mockito.when(metricsCollector.isVersionAdvertised()).thenReturn(false);
ServiceComponent metricsMonitor=Mockito.mock(ServiceComponent.class);
Mockito.when(metricsMonitor.getName()).thenReturn("METRICS_MONITOR");
Mockito.when(metricsMonitor.isClientComponent()).thenReturn(false);
Mockito.when(metricsMonitor.isVersionAdvertised()).thenReturn(false);
amsComponents.put("METRICS_COLLECTOR",metricsCollector);
amsComponents.put("METRICS_MONITOR",metricsMonitor);
Mockito.when(amsService.getServiceComponents()).thenReturn(amsComponents);
final HostComponentSummary hcsNameNode=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsDataNode1=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsDataNode2=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsDataNode3=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsZKFC=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsTezClient=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsMetricsCollector=Mockito.mock(HostComponentSummary.class);
final HostComponentSummary hcsMetricsMonitor=Mockito.mock(HostComponentSummary.class);
List allHostComponentSummaries=new ArrayList();
allHostComponentSummaries.add(hcsNameNode);
allHostComponentSummaries.add(hcsDataNode1);
allHostComponentSummaries.add(hcsDataNode2);
allHostComponentSummaries.add(hcsDataNode3);
allHostComponentSummaries.add(hcsZKFC);
allHostComponentSummaries.add(hcsTezClient);
allHostComponentSummaries.add(hcsMetricsCollector);
allHostComponentSummaries.add(hcsMetricsMonitor);
Mockito.when(HostComponentSummary.getHostComponentSummaries("HDFS","NAMENODE")).thenReturn(Arrays.asList(hcsNameNode));
Mockito.when(HostComponentSummary.getHostComponentSummaries("HDFS","DATANODE")).thenReturn(Arrays.asList(hcsDataNode1,hcsDataNode2,hcsDataNode3));
Mockito.when(HostComponentSummary.getHostComponentSummaries("HDFS","ZKFC")).thenReturn(Arrays.asList(hcsZKFC));
Mockito.when(HostComponentSummary.getHostComponentSummaries("TEZ","TEZ_CLIENT")).thenReturn(Arrays.asList(hcsTezClient));
Mockito.when(HostComponentSummary.getHostComponentSummaries("AMBARI_METRICS","METRICS_COLLECTOR")).thenReturn(Arrays.asList(hcsMetricsCollector));
Mockito.when(HostComponentSummary.getHostComponentSummaries("AMBARI_METRICS","METRICS_MONITOR")).thenReturn(Arrays.asList(hcsMetricsMonitor));
for ( HostComponentSummary hcs : allHostComponentSummaries) {
Mockito.when(hcs.getDesiredState()).thenReturn(State.INSTALLED);
Mockito.when(hcs.getCurrentState()).thenReturn(State.STARTED);
}
PrerequisiteCheck check=new PrerequisiteCheck(null,null);
servicesUpCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
Mockito.when(hcsNameNode.getDesiredState()).thenReturn(State.STARTED);
Mockito.when(hcsDataNode1.getDesiredState()).thenReturn(State.STARTED);
check=new PrerequisiteCheck(null,null);
servicesUpCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
Mockito.when(hcsZKFC.getCurrentState()).thenReturn(State.INSTALLED);
Mockito.when(hcsMetricsCollector.getCurrentState()).thenReturn(State.INSTALLED);
Mockito.when(hcsMetricsMonitor.getCurrentState()).thenReturn(State.INSTALLED);
check=new PrerequisiteCheck(null,null);
servicesUpCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
Mockito.when(hcsNameNode.getCurrentState()).thenReturn(State.INSTALLED);
Mockito.when(hcsDataNode1.getCurrentState()).thenReturn(State.INSTALLED);
check=new PrerequisiteCheck(null,null);
servicesUpCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
Mockito.when(hcsNameNode.getCurrentState()).thenReturn(State.STARTED);
Mockito.when(hcsDataNode1.getCurrentState()).thenReturn(State.INSTALLED);
check=new PrerequisiteCheck(null,null);
servicesUpCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.PASS,check.getStatus());
Mockito.when(hcsNameNode.getCurrentState()).thenReturn(State.STARTED);
Mockito.when(hcsDataNode1.getCurrentState()).thenReturn(State.INSTALLED);
Mockito.when(hcsDataNode2.getCurrentState()).thenReturn(State.INSTALLED);
check=new PrerequisiteCheck(null,null);
servicesUpCheck.perform(check,new PrereqCheckRequest("cluster"));
Assert.assertEquals(PrereqCheckStatus.FAIL,check.getStatus());
Assert.assertTrue(check.getFailReason().indexOf("50%") > -1);
}
Class: org.apache.ambari.server.checks.ServicesYarnWorkPreservingCheckTest InternalCallVerifier BooleanVerifier services=new HashMap<>();
final Service service=Mockito.mock(Service.class);
services.put("YARN",service);
Mockito.when(cluster.getServices()).thenReturn(services);
Mockito.when(cluster.getClusterId()).thenReturn(1L);
Mockito.when(clusters.getCluster("cluster")).thenReturn(cluster);
Assert.assertTrue(servicesYarnWorkPreservingCheck.isApplicable(new PrereqCheckRequest("cluster")));
services.remove("YARN");
Assert.assertFalse(servicesYarnWorkPreservingCheck.isApplicable(new PrereqCheckRequest("cluster")));
}
Class: org.apache.ambari.server.checks.UpgradeCheckOrderTest BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier checks=registry.getUpgradeChecks();
ClassPathScanningCandidateComponentProvider scanner=new ClassPathScanningCandidateComponentProvider(false);
AssignableTypeFilter filter=new AssignableTypeFilter(AbstractCheckDescriptor.class);
scanner.addIncludeFilter(filter);
Set beanDefinitions=scanner.findCandidateComponents("org.apache.ambari.server");
Assert.assertEquals(beanDefinitions.size(),checks.size());
AbstractCheckDescriptor lastCheck=null;
for ( AbstractCheckDescriptor check : checks) {
UpgradeCheckGroup group=UpgradeCheckGroup.DEFAULT;
UpgradeCheckGroup lastGroup=UpgradeCheckGroup.DEFAULT;
if (null != lastCheck) {
UpgradeCheck annotation=check.getClass().getAnnotation(UpgradeCheck.class);
UpgradeCheck lastAnnotation=lastCheck.getClass().getAnnotation(UpgradeCheck.class);
if (null != annotation && null != lastAnnotation) {
group=annotation.group();
lastGroup=lastAnnotation.group();
Assert.assertTrue(lastGroup.getOrder().compareTo(group.getOrder()) <= 0);
}
}
lastCheck=check;
}
}
Class: org.apache.ambari.server.checks.YarnTimelineServerStatePreservingCheckTest InternalCallVerifier BooleanVerifier (){
{
put("YARN",null);
}
}
);
Mockito.when(cluster.getCurrentStackVersion()).thenReturn(new StackId("MYSTACK-12.2"));
ClusterVersionEntity clusterVersionEntity=Mockito.mock(ClusterVersionEntity.class);
Mockito.when(cluster.getCurrentClusterVersion()).thenReturn(clusterVersionEntity);
RepositoryVersionEntity repositoryVersionEntity=Mockito.mock(RepositoryVersionEntity.class);
Mockito.when(clusterVersionEntity.getRepositoryVersion()).thenReturn(repositoryVersionEntity);
Mockito.when(m_clusters.getCluster("c1")).thenReturn(cluster);
Map checkProperties=new HashMap();
checkProperties.put("min-applicable-stack-version","HDP-2.2.4.2");
PrerequisiteCheckConfig prerequisiteCheckConfig=Mockito.mock(PrerequisiteCheckConfig.class);
Mockito.when(prerequisiteCheckConfig.getCheckProperties(m_check.getClass().getName())).thenReturn(checkProperties);
PrereqCheckRequest request=new PrereqCheckRequest("c1");
request.setPrerequisiteCheckConfig(prerequisiteCheckConfig);
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.3.0.1");
boolean isApplicable=m_check.isApplicable(request);
Assert.assertTrue(isApplicable);
}
InternalCallVerifier BooleanVerifier services=new HashMap();
Mockito.when(cluster.getServices()).thenReturn(services);
ClusterVersionEntity clusterVersionEntity=Mockito.mock(ClusterVersionEntity.class);
Mockito.when(cluster.getCurrentClusterVersion()).thenReturn(clusterVersionEntity);
RepositoryVersionEntity repositoryVersionEntity=Mockito.mock(RepositoryVersionEntity.class);
Mockito.when(clusterVersionEntity.getRepositoryVersion()).thenReturn(repositoryVersionEntity);
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.2.4.2");
Map checkProperties=new HashMap();
checkProperties.put("min-applicable-stack-version","HDP-2.2.4.2");
PrerequisiteCheckConfig prerequisiteCheckConfig=Mockito.mock(PrerequisiteCheckConfig.class);
Mockito.when(prerequisiteCheckConfig.getCheckProperties(m_check.getClass().getName())).thenReturn(checkProperties);
PrereqCheckRequest request=new PrereqCheckRequest("cluster");
request.setRepositoryVersion("2.3.0.0");
request.setPrerequisiteCheckConfig(prerequisiteCheckConfig);
Assert.assertFalse(m_check.isApplicable(request));
services.put("YARN",Mockito.mock(Service.class));
Assert.assertTrue(m_check.isApplicable(request));
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.2.0.0");
Assert.assertFalse(m_check.isApplicable(request));
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.2.4.2");
Assert.assertTrue(m_check.isApplicable(request));
}
InternalCallVerifier BooleanVerifier (){
{
put("YARN",null);
}
}
);
Mockito.when(cluster.getCurrentStackVersion()).thenReturn(new StackId("HDP-2.2"));
ClusterVersionEntity clusterVersionEntity=Mockito.mock(ClusterVersionEntity.class);
Mockito.when(cluster.getCurrentClusterVersion()).thenReturn(clusterVersionEntity);
RepositoryVersionEntity repositoryVersionEntity=Mockito.mock(RepositoryVersionEntity.class);
Mockito.when(clusterVersionEntity.getRepositoryVersion()).thenReturn(repositoryVersionEntity);
Mockito.when(m_clusters.getCluster("c1")).thenReturn(cluster);
Map checkProperties=new HashMap();
checkProperties.put("min-applicable-stack-version","HDP-2.2.4.2");
PrerequisiteCheckConfig prerequisiteCheckConfig=Mockito.mock(PrerequisiteCheckConfig.class);
Mockito.when(prerequisiteCheckConfig.getCheckProperties(m_check.getClass().getName())).thenReturn(checkProperties);
PrereqCheckRequest request=new PrereqCheckRequest("c1");
request.setPrerequisiteCheckConfig(prerequisiteCheckConfig);
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.1.1.1");
boolean isApplicable=m_check.isApplicable(request);
Assert.assertFalse(isApplicable);
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.2.4.1");
isApplicable=m_check.isApplicable(request);
Assert.assertFalse(isApplicable);
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.2.4.2");
isApplicable=m_check.isApplicable(request);
Assert.assertTrue(isApplicable);
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.2.4.4");
isApplicable=m_check.isApplicable(request);
Assert.assertTrue(isApplicable);
Mockito.when(repositoryVersionEntity.getVersion()).thenReturn("2.3.1.1");
isApplicable=m_check.isApplicable(request);
Assert.assertTrue(isApplicable);
}
Class: org.apache.ambari.server.configuration.ConfigurationTest InternalCallVerifier NullVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier props=conf.getAmbariProperties();
verifyAll();
Assert.assertEquals("value",props.get("name"));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.ActionRequestTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.ActionResponseTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.AmbariCustomCommandExecutionHelperTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier requestProperties=new HashMap(){
{
put("context","Restart all components for GANGLIA");
put("operation_level/level","SERVICE");
put("operation_level/service_name","GANGLIA");
put("operation_level/cluster_name","c1");
}
}
;
ExecuteActionRequest actionRequest=new ExecuteActionRequest("c1","RESTART",null,Arrays.asList(new RequestResourceFilter("GANGLIA","GANGLIA_SERVER",Collections.singletonList("c6401")),new RequestResourceFilter("GANGLIA","GANGLIA_MONITOR",Collections.singletonList("c6401")),new RequestResourceFilter("GANGLIA","GANGLIA_MONITOR",Collections.singletonList("c6402"))),new RequestOperationLevel(Resource.Type.Service,"c1","GANGLIA",null,null),new HashMap(){
{
}
}
,false);
controller.createAction(actionRequest,requestProperties);
Mockito.verify(am,Mockito.times(1)).sendActions(requestCapture.capture(),any(ExecuteActionRequest.class));
Request request=requestCapture.getValue();
Assert.assertNotNull(request);
Assert.assertNotNull(request.getStages());
Assert.assertEquals(1,request.getStages().size());
Stage stage=request.getStages().iterator().next();
Assert.assertEquals(2,stage.getHostRoleCommands().size());
}
InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier requestProperties=new HashMap(){
{
put(REQUEST_CONTEXT_PROPERTY,"Refresh YARN Capacity Scheduler");
put("command","REFRESHQUEUES");
}
}
;
ExecuteActionRequest actionRequest=new ExecuteActionRequest("c1","REFRESHQUEUES",new HashMap(){
{
put("forceRefreshConfigTags","capacity-scheduler");
}
}
,false);
actionRequest.getResourceFilters().add(new RequestResourceFilter("YARN","RESOURCEMANAGER",Collections.singletonList("c6401")));
controller.createAction(actionRequest,requestProperties);
Mockito.verify(am,Mockito.times(1)).sendActions(requestCapture.capture(),any(ExecuteActionRequest.class));
Request request=requestCapture.getValue();
Assert.assertNotNull(request);
Assert.assertNotNull(request.getStages());
Assert.assertEquals(1,request.getStages().size());
Stage stage=request.getStages().iterator().next();
Assert.assertEquals(1,stage.getHosts().size());
List commands=stage.getExecutionCommands("c6401");
Assert.assertEquals(1,commands.size());
ExecutionCommand command=commands.get(0).getExecutionCommand();
Assert.assertNotNull(command.getForceRefreshConfigTags());
Assert.assertEquals(1,command.getForceRefreshConfigTags().size());
Assert.assertEquals("capacity-scheduler",command.getForceRefreshConfigTags().iterator().next());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier requestProperties=new HashMap(){
{
put("context","Restart all components for GANGLIA");
put("operation_level/level","SERVICE");
put("operation_level/service_name","GANGLIA");
put("operation_level/cluster_name","c1");
}
}
;
ExecuteActionRequest actionRequest=new ExecuteActionRequest("c1","RESTART",null,Arrays.asList(new RequestResourceFilter("GANGLIA","GANGLIA_SERVER",Collections.singletonList("c6401")),new RequestResourceFilter("GANGLIA","GANGLIA_MONITOR",Collections.singletonList("c6401")),new RequestResourceFilter("GANGLIA","GANGLIA_MONITOR",Collections.singletonList("c6402"))),new RequestOperationLevel(Resource.Type.Service,"c1","GANGLIA",null,null),new HashMap(){
{
}
}
,false);
controller.createAction(actionRequest,requestProperties);
Mockito.verify(am,Mockito.times(1)).sendActions(requestCapture.capture(),any(ExecuteActionRequest.class));
Request request=requestCapture.getValue();
Assert.assertNotNull(request);
Assert.assertNotNull(request.getStages());
Assert.assertEquals(1,request.getStages().size());
Stage stage=request.getStages().iterator().next();
Assert.assertEquals(1,stage.getHostRoleCommands().size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier requestProperties=new HashMap(){
{
put("context","Restart all components for GANGLIA");
put("operation_level/level","SERVICE");
put("operation_level/service_name","GANGLIA");
put("operation_level/cluster_name","c1");
}
}
;
ExecuteActionRequest actionRequest=new ExecuteActionRequest("c1","RESTART",null,Arrays.asList(new RequestResourceFilter("GANGLIA","GANGLIA_SERVER",Collections.singletonList("c6401")),new RequestResourceFilter("GANGLIA","GANGLIA_MONITOR",Collections.singletonList("c6401")),new RequestResourceFilter("GANGLIA","GANGLIA_MONITOR",Collections.singletonList("c6402"))),new RequestOperationLevel(Resource.Type.Host,"c1","GANGLIA",null,null),new HashMap(){
{
}
}
,false);
controller.createAction(actionRequest,requestProperties);
Mockito.verify(am,Mockito.times(1)).sendActions(requestCapture.capture(),any(ExecuteActionRequest.class));
Request request=requestCapture.getValue();
Assert.assertNotNull(request);
Assert.assertNotNull(request.getStages());
Assert.assertEquals(1,request.getStages().size());
Stage stage=request.getStages().iterator().next();
Assert.assertEquals(1,stage.getHostRoleCommands().size());
}
Class: org.apache.ambari.server.controller.AmbariHandlerListTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier securityHeaderFilterCapture=new Capture();
Capture persistFilterCapture=new Capture();
Capture securityFilterCapture=new Capture();
handler.addFilter(capture(securityHeaderFilterCapture),eq("/*"),eq(AmbariServer.DISPATCHER_TYPES));
handler.addFilter(capture(persistFilterCapture),eq("/*"),eq(AmbariServer.DISPATCHER_TYPES));
handler.addFilter(capture(securityFilterCapture),eq("/*"),eq(AmbariServer.DISPATCHER_TYPES));
handler.setAllowNullPathInfo(true);
replay(handler,server);
AmbariHandlerList handlerList=getAmbariHandlerList(handler);
handlerList.addViewInstance(viewInstanceEntity);
ArrayList handlers=new ArrayList(Arrays.asList(handlerList.getHandlers()));
Assert.assertTrue(handlers.contains(handler));
Assert.assertEquals(ambariViewsSecurityHeaderFilter,securityHeaderFilterCapture.getValue().getFilter());
Assert.assertEquals(persistFilter,persistFilterCapture.getValue().getFilter());
Assert.assertEquals(springSecurityFilter,securityFilterCapture.getValue().getFilter());
verify(handler,server);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier handlers=new ArrayList(Arrays.asList(handlerList.getHandlers()));
Assert.assertTrue(handlers.contains(handler));
handlerList.removeViewInstance(viewInstanceEntity);
handlers=new ArrayList(Arrays.asList(handlerList.getHandlers()));
Assert.assertFalse(handlers.contains(handler));
verify(handler,server);
}
Class: org.apache.ambari.server.controller.AmbariManagementControllerImplTest InternalCallVerifier EqualityVerifier ());
replay(ambariManagementControllerImpl);
Class amciClass=AmbariManagementControllerImpl.class;
Field f=amciClass.getDeclaredField("configs");
f.setAccessible(true);
f.set(ambariManagementControllerImpl,configuration);
AmbariCustomCommandExecutionHelper helper=new AmbariCustomCommandExecutionHelper();
Class helperClass=AmbariCustomCommandExecutionHelper.class;
f=helperClass.getDeclaredField("managementController");
f.setAccessible(true);
f.set(helper,ambariManagementControllerImpl);
f=helperClass.getDeclaredField("configs");
f.setAccessible(true);
f.set(helper,configuration);
f=helperClass.getDeclaredField("clusterVersionDAO");
f.setAccessible(true);
f.set(helper,clusterVersionDAO);
Map defaultHostParams=helper.createDefaultHostParams(cluster);
assertEquals(defaultHostParams.size(),13);
assertEquals(defaultHostParams.get(DB_DRIVER_FILENAME),MYSQL_JAR);
assertEquals(defaultHostParams.get(STACK_NAME),SOME_STACK_NAME);
assertEquals(defaultHostParams.get(STACK_VERSION),SOME_STACK_VERSION);
assertEquals("true",defaultHostParams.get(HOST_SYS_PREPPED));
assertEquals("8",defaultHostParams.get(JAVA_VERSION));
}
UtilityVerifier InternalCallVerifier IdentityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
Cluster cluster=createNiceMock(Cluster.class);
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1","host1",null);
ServiceComponentHostRequest request2=new ServiceComponentHostRequest("cluster1",null,"component2","host1",null);
ServiceComponentHostRequest request3=new ServiceComponentHostRequest("cluster1",null,"component3","host1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(clusters.getClustersForHost("host1")).andThrow(new HostNotFoundException("host1"));
replay(maintHelper,injector,clusters,cluster,stack,ambariMetaInfo);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
try {
controller.getHostComponents(setRequests);
fail("expected exception");
}
catch ( AmbariException e) {
}
assertSame(controller,controllerCapture.getValue());
verify(injector,clusters,cluster,stack,ambariMetaInfo);
}
InternalCallVerifier EqualityVerifier controllerCapture=new Capture();
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
replay(injector);
AmbariManagementControllerImpl controller=new AmbariManagementControllerImpl(null,null,injector);
class AmbariConfigsSetter {
public void setConfigs( AmbariManagementController controller, String masterProtocol, String masterHostname, Integer masterPort) throws Exception {
Class c=controller.getClass();
Field f=c.getDeclaredField("masterProtocol");
f.setAccessible(true);
Field modifiersField=Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(f,f.getModifiers() & ~Modifier.FINAL);
f.set(controller,masterProtocol);
f=c.getDeclaredField("masterHostname");
f.setAccessible(true);
modifiersField=Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(f,f.getModifiers() & ~Modifier.FINAL);
f.set(controller,masterHostname);
f=c.getDeclaredField("masterPort");
f.setAccessible(true);
modifiersField=Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(f,f.getModifiers() & ~Modifier.FINAL);
f.set(controller,masterPort);
}
}
AmbariConfigsSetter ambariConfigsSetter=new AmbariConfigsSetter();
ambariConfigsSetter.setConfigs(controller,"http","hostname",8080);
assertEquals("http://hostname:8080/jdk_path",controller.getAmbariServerURI("/jdk_path"));
ambariConfigsSetter.setConfigs(controller,"https","somesecuredhost",8443);
assertEquals("https://somesecuredhost:8443/mysql_path",controller.getAmbariServerURI("/mysql_path"));
ambariConfigsSetter.setConfigs(controller,"https","othersecuredhost",8443);
assertEquals("https://othersecuredhost:8443/oracle/ojdbc/",controller.getAmbariServerURI("/oracle/ojdbc/"));
ambariConfigsSetter.setConfigs(controller,"http","hostname",8080);
assertEquals("http://hostname:8080/jdk_path?query",controller.getAmbariServerURI("/jdk_path?query"));
verify(injector);
}
InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
Cluster cluster=createNiceMock(Cluster.class);
final Host host=createNiceMock(Host.class);
Service service=createNiceMock(Service.class);
Service service2=createNiceMock(Service.class);
ServiceComponent component=createNiceMock(ServiceComponent.class);
ServiceComponent component2=createNiceMock(ServiceComponent.class);
ServiceComponent component3=createNiceMock(ServiceComponent.class);
final ServiceComponentHost componentHost1=createNiceMock(ServiceComponentHost.class);
final ServiceComponentHost componentHost2=createNiceMock(ServiceComponentHost.class);
ServiceComponentHostResponse response1=createNiceMock(ServiceComponentHostResponse.class);
ServiceComponentHostResponse response2=createNiceMock(ServiceComponentHostResponse.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
expect(maintHelper.getEffectiveState(anyObject(ServiceComponentHost.class),anyObject(Host.class))).andReturn(MaintenanceState.OFF).anyTimes();
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1",null,null);
ServiceComponentHostRequest request2=new ServiceComponentHostRequest("cluster1",null,"component2","host2",null);
ServiceComponentHostRequest request3=new ServiceComponentHostRequest("cluster1",null,"component3",null,null);
Set setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster).times(3);
expect(clusters.getHostsForCluster((String)anyObject())).andReturn(new HashMap(){
{
put("host1",host);
}
}
).anyTimes();
expect(cluster.getDesiredStackVersion()).andReturn(stack).anyTimes();
expect(stack.getStackName()).andReturn("stackName").anyTimes();
expect(stack.getStackVersion()).andReturn("stackVersion").anyTimes();
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component1")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component1")).andReturn(component);
expect(component.getName()).andReturn("component1");
expect(component.getServiceComponentHosts()).andReturn(Collections.singletonMap("foo",componentHost1));
expect(componentHost1.convertToResponse()).andReturn(response1);
expect(componentHost1.getHostName()).andReturn("host1");
expect(clusters.getClustersForHost("host2")).andThrow(new HostNotFoundException("host2"));
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component3")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component3")).andReturn(component3);
expect(component3.getName()).andReturn("component3");
expect(component3.getServiceComponentHosts()).andReturn(Collections.singletonMap("foo",componentHost2));
expect(componentHost2.convertToResponse()).andReturn(response2);
expect(componentHost2.getHostName()).andReturn("host1");
replay(maintHelper,injector,clusters,cluster,host,stack,ambariMetaInfo,service,service2,component,component2,component3,componentHost1,componentHost2,response1,response2);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
Set setResponses=controller.getHostComponents(setRequests);
Assert.assertNotNull(setResponses);
assertSame(controller,controllerCapture.getValue());
assertEquals(2,setResponses.size());
assertTrue(setResponses.contains(response1));
assertTrue(setResponses.contains(response2));
verify(injector,clusters,cluster,host,stack,ambariMetaInfo,service,service2,component,component2,component3,componentHost1,componentHost2,response1,response2);
}
InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
Cluster cluster=createNiceMock(Cluster.class);
final Host host=createNiceMock(Host.class);
Service service=createNiceMock(Service.class);
ServiceComponent component=createNiceMock(ServiceComponent.class);
final ServiceComponentHost componentHost=createNiceMock(ServiceComponentHost.class);
ServiceComponentHostResponse response=createNiceMock(ServiceComponentHostResponse.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
expect(maintHelper.getEffectiveState(componentHost)).andReturn(MaintenanceState.OFF).anyTimes();
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1","host1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(clusters.getClustersForHost("host1")).andReturn(Collections.singleton(cluster));
expect(clusters.getHostsForCluster((String)anyObject())).andReturn(new HashMap(){
{
put("host1",host);
}
}
).anyTimes();
expect(cluster.getDesiredStackVersion()).andReturn(stack);
expect(stack.getStackName()).andReturn("stackName");
expect(stack.getStackVersion()).andReturn("stackVersion");
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component1")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component1")).andReturn(component);
expect(component.getName()).andReturn("component1");
expect(component.getServiceComponentHosts()).andReturn(new HashMap(){
{
put("host1",componentHost);
}
}
);
expect(componentHost.convertToResponse()).andReturn(response);
expect(componentHost.getHostName()).andReturn("host1").anyTimes();
expect(maintHelper.getEffectiveState(componentHost,host)).andReturn(MaintenanceState.OFF);
replay(maintHelper,injector,clusters,cluster,host,response,stack,ambariMetaInfo,service,component,componentHost);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
Set setResponses=controller.getHostComponents(setRequests);
assertSame(controller,controllerCapture.getValue());
assertEquals(1,setResponses.size());
assertTrue(setResponses.contains(response));
verify(injector,clusters,cluster,host,response,stack,ambariMetaInfo,service,component,componentHost);
}
InternalCallVerifier IdentityVerifier controllerCapture=new Capture();
Injector injector=createStrictMock(Injector.class);
Cluster cluster=createNiceMock(Cluster.class);
ActionManager actionManager=createNiceMock(ActionManager.class);
ClusterRequest clusterRequest=createNiceMock(ClusterRequest.class);
Set setRequests=Collections.singleton(clusterRequest);
KerberosHelper kerberosHelper=createStrictMock(KerberosHelper.class);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(kerberosHelper);
expect(clusterRequest.getClusterId()).andReturn(1L).times(6);
expect(clusterRequest.getSecurityType()).andReturn(SecurityType.KERBEROS).anyTimes();
expect(clusters.getClusterById(1L)).andReturn(cluster).times(2);
expect(cluster.getClusterName()).andReturn("cluster").times(1);
expect(cluster.getSecurityType()).andReturn(SecurityType.NONE).anyTimes();
cluster.addSessionAttributes(anyObject(Map.class));
expectLastCall().once();
expect(kerberosHelper.shouldExecuteCustomOperations(SecurityType.KERBEROS,null)).andReturn(false).once();
expect(kerberosHelper.getManageIdentitiesDirective(null)).andReturn(null).once();
expect(kerberosHelper.toggleKerberos(anyObject(Cluster.class),anyObject(SecurityType.class),anyObject(RequestStageContainer.class),anyBoolean())).andReturn(null).once();
replay(actionManager,cluster,clusters,injector,clusterRequest,sessionManager,kerberosHelper);
AmbariManagementController controller=new AmbariManagementControllerImpl(actionManager,clusters,injector);
controller.updateClusters(setRequests,null);
assertSame(controller,controllerCapture.getValue());
verify(actionManager,cluster,clusters,injector,clusterRequest,sessionManager,kerberosHelper);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentsMap=new HashMap();
componentsMap.put("component1",component1);
componentsMap.put("component2",component2);
expect(service.getServiceComponents()).andReturn(componentsMap);
expect(component1.getServiceComponentHosts()).andReturn(Collections.EMPTY_MAP);
expect(component2.getServiceComponentHosts()).andReturn(Collections.singletonMap("anyHost",null));
ServiceInfo serviceInfo=createNiceMock(ServiceInfo.class);
ComponentInfo compInfo=createNiceMock(ComponentInfo.class);
expect(serviceInfo.getClientComponent()).andReturn(compInfo);
expect(compInfo.getName()).andReturn("component");
expect(ambariMetaInfo.getService("stack","1.0","service")).andReturn(serviceInfo);
replay(injector,cluster,service,component1,component2,serviceInfo,compInfo,ambariMetaInfo,stackId);
AmbariManagementControllerImpl controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
ServiceComponent resultComponent=controller.getClientComponentForRunningAction(cluster,service);
assertNotNull(resultComponent);
assertEquals(component2,resultComponent);
verify(injector,cluster,service,component1,component2,serviceInfo,compInfo,ambariMetaInfo,stackId);
}
InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
Cluster cluster=createNiceMock(Cluster.class);
Service service1=createNiceMock(Service.class);
Service service2=createNiceMock(Service.class);
ServiceComponent component1=createNiceMock(ServiceComponent.class);
ServiceComponent component2=createNiceMock(ServiceComponent.class);
ServiceComponentHost componentHost1=createNiceMock(ServiceComponentHost.class);
ServiceComponentHost componentHost2=createNiceMock(ServiceComponentHost.class);
ServiceComponentHost componentHost3=createNiceMock(ServiceComponentHost.class);
ServiceComponentHostResponse response1=createNiceMock(ServiceComponentHostResponse.class);
ServiceComponentHostResponse response2=createNiceMock(ServiceComponentHostResponse.class);
ServiceComponentHostResponse response3=createNiceMock(ServiceComponentHostResponse.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
expect(maintHelper.getEffectiveState(anyObject(ServiceComponentHost.class),anyObject(Host.class))).andReturn(MaintenanceState.OFF).anyTimes();
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,null,null,null);
Set setRequests=new HashSet();
setRequests.add(request1);
Map mapServices=new HashMap();
mapServices.put("foo",service1);
mapServices.put("bar",service2);
Map mapHostComponents=new HashMap();
mapHostComponents.put("foo",componentHost1);
mapHostComponents.put("bar",componentHost2);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(clusters.getHostsForCluster((String)anyObject())).andReturn(new HashMap(){
{
put("host1",createNiceMock(Host.class));
}
}
).anyTimes();
expect(cluster.getServices()).andReturn(mapServices);
expect(service1.getServiceComponents()).andReturn(Collections.singletonMap("foo",component1));
expect(service2.getServiceComponents()).andReturn(Collections.singletonMap("bar",component2));
expect(component1.getName()).andReturn("component1").anyTimes();
expect(component2.getName()).andReturn("component2").anyTimes();
expect(component1.getServiceComponentHosts()).andReturn(mapHostComponents);
expect(componentHost1.convertToResponse()).andReturn(response1);
expect(componentHost2.convertToResponse()).andReturn(response2);
expect(componentHost1.getHostName()).andReturn("host1");
expect(componentHost2.getHostName()).andReturn("host1");
expect(componentHost3.getHostName()).andReturn("host1");
expect(component2.getServiceComponentHosts()).andReturn(Collections.singletonMap("foobar",componentHost3));
expect(componentHost3.convertToResponse()).andReturn(response3);
replay(maintHelper,injector,clusters,cluster,response1,response2,response3,stack,ambariMetaInfo,service1,service2,component1,component2,componentHost1,componentHost2,componentHost3);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
Set setResponses=controller.getHostComponents(setRequests);
assertSame(controller,controllerCapture.getValue());
assertEquals(3,setResponses.size());
assertTrue(setResponses.contains(response1));
assertTrue(setResponses.contains(response2));
assertTrue(setResponses.contains(response3));
verify(injector,clusters,cluster,response1,response2,response3,stack,ambariMetaInfo,service1,service2,component1,component2,componentHost1,componentHost2,componentHost3);
}
InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
Cluster cluster=createNiceMock(Cluster.class);
final Host host=createNiceMock(Host.class);
Service service=createNiceMock(Service.class);
ServiceComponent component=createNiceMock(ServiceComponent.class);
ServiceComponent component2=createNiceMock(ServiceComponent.class);
ServiceComponent component3=createNiceMock(ServiceComponent.class);
final ServiceComponentHost componentHost1=createNiceMock(ServiceComponentHost.class);
final ServiceComponentHost componentHost2=createNiceMock(ServiceComponentHost.class);
ServiceComponentHostResponse response1=createNiceMock(ServiceComponentHostResponse.class);
ServiceComponentHostResponse response2=createNiceMock(ServiceComponentHostResponse.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
expect(maintHelper.getEffectiveState(anyObject(ServiceComponentHost.class),anyObject(Host.class))).andReturn(MaintenanceState.OFF).anyTimes();
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1","host1",null);
ServiceComponentHostRequest request2=new ServiceComponentHostRequest("cluster1",null,"component2","host1",null);
ServiceComponentHostRequest request3=new ServiceComponentHostRequest("cluster1",null,"component3","host1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster).times(3);
expect(clusters.getClustersForHost("host1")).andReturn(Collections.singleton(cluster)).anyTimes();
expect(cluster.getDesiredStackVersion()).andReturn(stack).anyTimes();
expect(stack.getStackName()).andReturn("stackName").anyTimes();
expect(stack.getStackVersion()).andReturn("stackVersion").anyTimes();
expect(clusters.getHostsForCluster((String)anyObject())).andReturn(new HashMap(){
{
put("host1",host);
}
}
).anyTimes();
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component1")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component1")).andReturn(component);
expect(component.getName()).andReturn("component1");
expect(component.getServiceComponentHosts()).andReturn(new HashMap(){
{
put("host1",componentHost1);
}
}
);
expect(componentHost1.convertToResponse()).andReturn(response1);
expect(componentHost1.getHostName()).andReturn("host1");
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component2")).andReturn("service2");
expect(cluster.getService("service2")).andThrow(new ServiceNotFoundException("cluster1","service2"));
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component3")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component3")).andReturn(component3);
expect(component3.getName()).andReturn("component3");
expect(component3.getServiceComponentHosts()).andReturn(new HashMap(){
{
put("host1",componentHost2);
}
}
);
expect(componentHost2.convertToResponse()).andReturn(response2);
expect(componentHost2.getHostName()).andReturn("host1");
replay(maintHelper,injector,clusters,cluster,host,stack,ambariMetaInfo,service,component,component2,component3,componentHost1,componentHost2,response1,response2);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
Set setResponses=controller.getHostComponents(setRequests);
assertSame(controller,controllerCapture.getValue());
assertEquals(2,setResponses.size());
assertTrue(setResponses.contains(response1));
assertTrue(setResponses.contains(response2));
verify(injector,clusters,cluster,host,stack,ambariMetaInfo,service,component,component2,component3,componentHost1,componentHost2,response1,response2);
}
UtilityVerifier InternalCallVerifier IdentityVerifier HybridVerifier controllerCapture=new Capture();
Injector injector=createStrictMock(Injector.class);
Cluster cluster=createMock(Cluster.class);
ActionManager actionManager=createNiceMock(ActionManager.class);
ClusterRequest clusterRequest=createNiceMock(ClusterRequest.class);
Set setRequests=Collections.singleton(clusterRequest);
KerberosHelper kerberosHelper=createStrictMock(KerberosHelper.class);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(kerberosHelper);
expect(clusterRequest.getClusterId()).andReturn(1L).times(6);
expect(clusterRequest.getSecurityType()).andReturn(SecurityType.NONE).anyTimes();
expect(clusters.getClusterById(1L)).andReturn(cluster).times(2);
expect(cluster.getResourceId()).andReturn(1L).times(3);
expect(cluster.getClusterName()).andReturn("cluster").times(1);
expect(cluster.getSecurityType()).andReturn(SecurityType.KERBEROS).anyTimes();
expect(cluster.getCurrentClusterVersion()).andReturn(null).anyTimes();
expect(cluster.getCurrentStackVersion()).andReturn(null).anyTimes();
expect(cluster.getDesiredStackVersion()).andReturn(null).anyTimes();
cluster.setCurrentStackVersion(anyObject(StackId.class));
expectLastCall().once();
cluster.setClusterName(anyObject(String.class));
expectLastCall().once();
cluster.addSessionAttributes(anyObject(Map.class));
expectLastCall().once();
expect(kerberosHelper.shouldExecuteCustomOperations(SecurityType.NONE,null)).andReturn(false).once();
expect(kerberosHelper.getManageIdentitiesDirective(anyObject(Map.class))).andReturn(null).once();
expect(kerberosHelper.toggleKerberos(anyObject(Cluster.class),anyObject(SecurityType.class),anyObject(RequestStageContainer.class),anyBoolean())).andThrow(new IllegalArgumentException("bad args!")).once();
replay(actionManager,cluster,clusters,injector,clusterRequest,sessionManager,kerberosHelper);
AmbariManagementController controller=new AmbariManagementControllerImpl(actionManager,clusters,injector);
try {
controller.updateClusters(setRequests,null);
Assert.fail("IllegalArgumentException not thrown");
}
catch ( IllegalArgumentException e) {
}
assertSame(controller,controllerCapture.getValue());
verify(actionManager,cluster,clusters,injector,clusterRequest,sessionManager,kerberosHelper);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
ClusterRequest request1=new ClusterRequest(null,"cluster1","1",Collections.emptySet());
Cluster cluster=createNiceMock(Cluster.class);
ClusterResponse response=createNiceMock(ClusterResponse.class);
Set setRequests=new HashSet();
setRequests.add(request1);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(cluster.convertToResponse()).andReturn(response);
CredentialStoreService credentialStoreService=createNiceMock(CredentialStoreService.class);
expect(credentialStoreService.isInitialized(anyObject(CredentialStoreType.class))).andReturn(true).anyTimes();
replay(injector,clusters,cluster,response,credentialStoreService);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
Field f=controller.getClass().getDeclaredField("credentialStoreService");
f.setAccessible(true);
f.set(controller,credentialStoreService);
Set setResponses=controller.getClusters(setRequests);
assertEquals(1,setResponses.size());
assertTrue(setResponses.contains(response));
verify(injector,clusters,cluster,response,credentialStoreService);
}
UtilityVerifier InternalCallVerifier IdentityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1","host1",null);
ServiceComponentHostRequest request2=new ServiceComponentHostRequest("cluster1",null,"component2","host2",null);
ServiceComponentHostRequest request3=new ServiceComponentHostRequest("cluster1",null,"component3","host1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andThrow(new ClusterNotFoundException("cluster1"));
replay(maintHelper,injector,clusters,stack,ambariMetaInfo);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
try {
controller.getHostComponents(setRequests);
fail("expected exception");
}
catch ( ParentObjectNotFoundException e) {
}
assertSame(controller,controllerCapture.getValue());
verify(injector,clusters,stack,ambariMetaInfo);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier componentsMap=new HashMap();
componentsMap.put("component1",component1);
componentsMap.put("component2",component2);
expect(service.getServiceComponents()).andReturn(componentsMap);
expect(component1.getServiceComponentHosts()).andReturn(Collections.EMPTY_MAP);
expect(component2.getServiceComponentHosts()).andReturn(Collections.singletonMap("anyHost",null));
ServiceInfo serviceInfo=createNiceMock(ServiceInfo.class);
expect(serviceInfo.getClientComponent()).andReturn(null);
expect(ambariMetaInfo.getService("stack","1.0","service")).andReturn(serviceInfo);
replay(injector,cluster,service,component1,component2,serviceInfo,ambariMetaInfo,stackId);
AmbariManagementControllerImpl controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
ServiceComponent resultComponent=controller.getClientComponentForRunningAction(cluster,service);
assertNotNull(resultComponent);
assertEquals(component2,resultComponent);
verify(injector,cluster,service,component1,component2,serviceInfo,ambariMetaInfo,stackId);
}
UtilityVerifier InternalCallVerifier IdentityVerifier HybridVerifier controllerCapture=new Capture();
Injector injector=createStrictMock(Injector.class);
Cluster cluster=createNiceMock(Cluster.class);
ActionManager actionManager=createNiceMock(ActionManager.class);
ClusterRequest clusterRequest=createNiceMock(ClusterRequest.class);
Set setRequests=Collections.singleton(clusterRequest);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusterRequest.getClusterName()).andReturn("clusterNew").times(3);
expect(clusterRequest.getClusterId()).andReturn(1L).times(6);
expect(clusters.getClusterById(1L)).andReturn(cluster).times(2);
expect(cluster.getClusterName()).andReturn("clusterOld").times(1);
cluster.setClusterName("clusterNew");
expectLastCall().andThrow(new RollbackException());
replay(actionManager,cluster,clusters,injector,clusterRequest,sessionManager);
AmbariManagementController controller=new AmbariManagementControllerImpl(actionManager,clusters,injector);
try {
controller.updateClusters(setRequests,null);
fail("Expected RollbackException");
}
catch ( RollbackException e) {
}
assertSame(controller,controllerCapture.getValue());
verify(actionManager,cluster,clusters,injector,clusterRequest,sessionManager);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier hostMap=createNiceMock(Map.class);
Set hostsSet=createNiceMock(Set.class);
expect(hostMap.isEmpty()).andReturn(false);
expect(hostMap.keySet()).andReturn(hostsSet);
expect(component.getServiceComponentHosts()).andReturn(hostMap).times(2);
replay(cluster,service,component,injector,actionManager,hostMap,hostsSet);
AmbariManagementControllerImpl controller=createMockBuilder(AmbariManagementControllerImpl.class).addMockedMethod("filterHostsForAction").addMockedMethod("getHealthyHost").withConstructor(actionManager,clusters,injector).createMock();
expect(controller.getHealthyHost(hostsSet)).andReturn("healthy_host");
controller.filterHostsForAction(hostsSet,service,cluster,Resource.Type.Cluster);
expectLastCall().once();
replay(controller);
String host=controller.getClientHostForRunningAction(cluster,service,component);
assertEquals("healthy_host",host);
verify(controller,cluster,service,component,injector,hostMap);
}
InternalCallVerifier IdentityVerifier controllerCapture=new Capture();
Injector injector=createStrictMock(Injector.class);
Cluster cluster=createNiceMock(Cluster.class);
ActionManager actionManager=createNiceMock(ActionManager.class);
ClusterRequest clusterRequest=createNiceMock(ClusterRequest.class);
Set setRequests=Collections.singleton(clusterRequest);
KerberosHelper kerberosHelper=createStrictMock(KerberosHelper.class);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(kerberosHelper);
expect(clusterRequest.getClusterId()).andReturn(1L).times(6);
expect(clusters.getClusterById(1L)).andReturn(cluster).times(2);
expect(cluster.getClusterName()).andReturn("cluster").times(1);
cluster.addSessionAttributes(anyObject(Map.class));
expectLastCall().once();
replay(actionManager,cluster,clusters,injector,clusterRequest,sessionManager,kerberosHelper);
AmbariManagementController controller=new AmbariManagementControllerImpl(actionManager,clusters,injector);
controller.updateClusters(setRequests,null);
assertSame(controller,controllerCapture.getValue());
verify(actionManager,cluster,clusters,injector,clusterRequest,sessionManager,kerberosHelper);
}
InternalCallVerifier IdentityVerifier controllerCapture=new Capture();
Injector injector=createStrictMock(Injector.class);
Cluster cluster=createNiceMock(Cluster.class);
ActionManager actionManager=createNiceMock(ActionManager.class);
ClusterRequest clusterRequest=createNiceMock(ClusterRequest.class);
Set setRequests=Collections.singleton(clusterRequest);
KerberosHelper kerberosHelper=createStrictMock(KerberosHelper.class);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(kerberosHelper);
expect(clusterRequest.getClusterId()).andReturn(1L).times(6);
expect(clusterRequest.getSecurityType()).andReturn(SecurityType.KERBEROS).anyTimes();
expect(clusters.getClusterById(1L)).andReturn(cluster).times(2);
expect(cluster.getClusterName()).andReturn("cluster").times(1);
expect(cluster.getSecurityType()).andReturn(SecurityType.KERBEROS).anyTimes();
cluster.addSessionAttributes(anyObject(Map.class));
expectLastCall().once();
expect(kerberosHelper.shouldExecuteCustomOperations(SecurityType.KERBEROS,null)).andReturn(false).once();
replay(actionManager,cluster,clusters,injector,clusterRequest,sessionManager,kerberosHelper);
AmbariManagementController controller=new AmbariManagementControllerImpl(actionManager,clusters,injector);
controller.updateClusters(setRequests,null);
assertSame(controller,controllerCapture.getValue());
verify(actionManager,cluster,clusters,injector,clusterRequest,sessionManager,kerberosHelper);
}
InternalCallVerifier EqualityVerifier controllerCapture=new Capture();
Injector injector=createStrictMock(Injector.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
ServiceInfo serviceInfo=createNiceMock(ServiceInfo.class);
Map hostParams=new HashMap();
String osFamily="testOSFamily";
Map osSpecifics=new HashMap();
ServiceOsSpecific.Package package1=new ServiceOsSpecific.Package();
package1.setName("testrpm1");
ServiceOsSpecific.Package package2=new ServiceOsSpecific.Package();
package2.setName("testrpm2");
ServiceOsSpecific.Package package3=new ServiceOsSpecific.Package();
package3.setName("testrpm3");
List packageList1=new ArrayList();
packageList1.add(package1);
List packageList2=new ArrayList();
packageList2.add(package2);
packageList2.add(package3);
ServiceOsSpecific osSpecific1=new ServiceOsSpecific("testOSFamily");
osSpecific1.addPackages(packageList1);
ServiceOsSpecific osSpecific2=new ServiceOsSpecific("testOSFamily1,testOSFamily,testOSFamily2");
osSpecific2.addPackages(packageList2);
osSpecifics.put("testOSFamily",osSpecific1);
osSpecifics.put("testOSFamily1,testOSFamily,testOSFamily2",osSpecific2);
expect(serviceInfo.getOsSpecifics()).andReturn(osSpecifics);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
replay(maintHelper,injector,clusters,serviceInfo);
AmbariManagementControllerImplTest.NestedTestClass nestedTestClass=this.new NestedTestClass(null,clusters,injector);
ServiceOsSpecific serviceOsSpecific=nestedTestClass.populateServicePackagesInfo(serviceInfo,hostParams,osFamily);
assertEquals(serviceOsSpecific.getPackages().size(),3);
}
InternalCallVerifier BooleanVerifier IdentityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
Cluster cluster=createNiceMock(Cluster.class);
final Host host=createNiceMock(Host.class);
Service service=createNiceMock(Service.class);
ServiceComponent component=createNiceMock(ServiceComponent.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
final ServiceComponentHost componentHost1=createNiceMock(ServiceComponentHost.class);
ServiceComponentHostResponse response1=createNiceMock(ServiceComponentHostResponse.class);
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1","host1",null);
request1.setState("INSTALLED");
Set setRequests=new HashSet();
setRequests.add(request1);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(maintHelper.getEffectiveState(anyObject(ServiceComponentHost.class),anyObject(Host.class))).andReturn(MaintenanceState.OFF).anyTimes();
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(clusters.getClustersForHost("host1")).andReturn(Collections.singleton(cluster));
expect(clusters.getHostsForCluster((String)anyObject())).andReturn(new HashMap(){
{
put("host1",host);
}
}
).anyTimes();
expect(cluster.getDesiredStackVersion()).andReturn(stack);
expect(cluster.getClusterName()).andReturn("cl1");
expect(stack.getStackName()).andReturn("stackName");
expect(stack.getStackVersion()).andReturn("stackVersion");
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component1")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component1")).andReturn(component);
expect(component.getName()).andReturn("component1").anyTimes();
expect(component.getServiceComponentHosts()).andReturn(new HashMap(){
{
put("host1",componentHost1);
}
}
);
expect(componentHost1.getState()).andReturn(State.INSTALLED);
expect(componentHost1.convertToResponse()).andReturn(response1);
expect(componentHost1.getHostName()).andReturn("host1");
replay(maintHelper,injector,clusters,cluster,host,stack,ambariMetaInfo,service,component,componentHost1,response1);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
Set responses=controller.getHostComponents(setRequests);
assertSame(controller,controllerCapture.getValue());
assertTrue(responses.size() == 1);
verify(injector,clusters,cluster,host,stack,ambariMetaInfo,service,component,componentHost1,response1);
}
InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
Cluster cluster=createNiceMock(Cluster.class);
Cluster cluster2=createNiceMock(Cluster.class);
ClusterResponse response=createNiceMock(ClusterResponse.class);
ClusterResponse response2=createNiceMock(ClusterResponse.class);
ClusterRequest request1=new ClusterRequest(null,"cluster1","1",Collections.emptySet());
ClusterRequest request2=new ClusterRequest(null,"cluster2","1",Collections.emptySet());
ClusterRequest request3=new ClusterRequest(null,"cluster3","1",Collections.emptySet());
ClusterRequest request4=new ClusterRequest(null,"cluster4","1",Collections.emptySet());
Set setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
setRequests.add(request4);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andThrow(new ClusterNotFoundException("cluster1"));
expect(clusters.getCluster("cluster2")).andReturn(cluster);
expect(clusters.getCluster("cluster3")).andReturn(cluster2);
expect(clusters.getCluster("cluster4")).andThrow(new ClusterNotFoundException("cluster4"));
expect(cluster.convertToResponse()).andReturn(response);
expect(cluster2.convertToResponse()).andReturn(response2);
CredentialStoreService credentialStoreService=createNiceMock(CredentialStoreService.class);
expect(credentialStoreService.isInitialized(anyObject(CredentialStoreType.class))).andReturn(true).anyTimes();
replay(injector,clusters,cluster,cluster2,response,response2,credentialStoreService);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
Field f=controller.getClass().getDeclaredField("credentialStoreService");
f.setAccessible(true);
f.set(controller,credentialStoreService);
Set setResponses=controller.getClusters(setRequests);
assertSame(controller,controllerCapture.getValue());
assertEquals(2,setResponses.size());
assertTrue(setResponses.contains(response));
assertTrue(setResponses.contains(response2));
verify(injector,clusters,cluster,cluster2,response,response2,credentialStoreService);
}
InternalCallVerifier NullVerifier InternalCallVerifier NullVerifier hostMap=new HashMap();
expect(component.getServiceComponentHosts()).andReturn(hostMap);
replay(cluster,service,component,injector);
AmbariManagementControllerImpl controller=new AmbariManagementControllerImpl(null,clusters,injector);
String host=controller.getClientHostForRunningAction(cluster,service,component);
verify(cluster,service,component,injector);
assertNull(host);
}
InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
Cluster cluster=createNiceMock(Cluster.class);
final Host host=createNiceMock(Host.class);
Service service=createNiceMock(Service.class);
ServiceComponent component=createNiceMock(ServiceComponent.class);
ServiceComponent component2=createNiceMock(ServiceComponent.class);
ServiceComponent component3=createNiceMock(ServiceComponent.class);
final ServiceComponentHost componentHost1=createNiceMock(ServiceComponentHost.class);
final ServiceComponentHost componentHost2=createNiceMock(ServiceComponentHost.class);
ServiceComponentHostResponse response1=createNiceMock(ServiceComponentHostResponse.class);
ServiceComponentHostResponse response2=createNiceMock(ServiceComponentHostResponse.class);
MaintenanceStateHelper stateHelper=createNiceMock(MaintenanceStateHelper.class);
expect(stateHelper.getEffectiveState(anyObject(ServiceComponentHost.class),anyObject(Host.class))).andReturn(MaintenanceState.OFF).anyTimes();
expect(clusters.getHostsForCluster((String)anyObject())).andReturn(new HashMap(){
{
put("host1",host);
}
}
).anyTimes();
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1","host1",null);
ServiceComponentHostRequest request2=new ServiceComponentHostRequest("cluster1",null,"component2","host1",null);
ServiceComponentHostRequest request3=new ServiceComponentHostRequest("cluster1",null,"component3","host1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(stateHelper).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster).times(3);
expect(clusters.getClustersForHost("host1")).andReturn(Collections.singleton(cluster)).anyTimes();
expect(cluster.getService("service1")).andReturn(service).times(3);
expect(cluster.getDesiredStackVersion()).andReturn(stack).anyTimes();
expect(stack.getStackName()).andReturn("stackName").anyTimes();
expect(stack.getStackVersion()).andReturn("stackVersion").anyTimes();
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component1")).andReturn("service1");
expect(service.getServiceComponent("component1")).andReturn(component);
expect(component.getName()).andReturn("component1");
expect(component.getServiceComponentHosts()).andReturn(new HashMap(){
{
put("host1",componentHost1);
}
}
);
expect(componentHost1.convertToResponse()).andReturn(response1);
expect(componentHost1.getHostName()).andReturn("host1");
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component2")).andReturn("service1");
expect(service.getServiceComponent("component2")).andReturn(component2);
expect(component2.getName()).andReturn("component2");
expect(component2.getServiceComponentHosts()).andReturn(null);
expect(componentHost2.getHostName()).andReturn("host1");
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component3")).andReturn("service1");
expect(service.getServiceComponent("component3")).andReturn(component3);
expect(component3.getName()).andReturn("component3");
expect(component3.getServiceComponentHosts()).andReturn(new HashMap(){
{
put("host1",componentHost2);
}
}
);
expect(componentHost2.convertToResponse()).andReturn(response2);
replay(stateHelper,injector,clusters,cluster,host,stack,ambariMetaInfo,service,component,component2,component3,componentHost1,componentHost2,response1,response2);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
Set setResponses=controller.getHostComponents(setRequests);
assertSame(controller,controllerCapture.getValue());
assertEquals(2,setResponses.size());
assertTrue(setResponses.contains(response1));
assertTrue(setResponses.contains(response2));
verify(injector,clusters,cluster,host,stack,ambariMetaInfo,service,component,component2,component3,componentHost1,componentHost2,response1,response2);
}
UtilityVerifier InternalCallVerifier IdentityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
Cluster cluster=createNiceMock(Cluster.class);
Host host=createNiceMock(Host.class);
Service service=createNiceMock(Service.class);
ServiceComponent component=createNiceMock(ServiceComponent.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1","host1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(clusters.getClustersForHost("host1")).andReturn(Collections.singleton(cluster));
expect(cluster.getDesiredStackVersion()).andReturn(stack);
expect(stack.getStackName()).andReturn("stackName");
expect(stack.getStackVersion()).andReturn("stackVersion");
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component1")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component1")).andReturn(component);
expect(component.getName()).andReturn("component1").anyTimes();
expect(component.getServiceComponentHosts()).andReturn(null);
replay(maintHelper,injector,clusters,cluster,host,stack,ambariMetaInfo,service,component);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
try {
controller.getHostComponents(setRequests);
fail("expected ServiceComponentHostNotFoundException");
}
catch ( ServiceComponentHostNotFoundException e) {
}
assertSame(controller,controllerCapture.getValue());
verify(injector,clusters,cluster,host,stack,ambariMetaInfo,service,component);
}
InternalCallVerifier IdentityVerifier IgnoredMethod HybridVerifier controllerCapture=new Capture();
Injector injector=createStrictMock(Injector.class);
Cluster cluster=createNiceMock(Cluster.class);
ActionManager actionManager=createNiceMock(ActionManager.class);
ClusterRequest clusterRequest=createNiceMock(ClusterRequest.class);
Set setRequests=Collections.singleton(clusterRequest);
KerberosHelper kerberosHelper=createStrictMock(KerberosHelper.class);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(kerberosHelper);
expect(clusterRequest.getClusterName()).andReturn("clusterNew").anyTimes();
expect(clusterRequest.getClusterId()).andReturn(1L).anyTimes();
ConfigurationRequest configReq=new ConfigurationRequest();
final Map configReqProps=Maps.newHashMap();
configReqProps.put("p1",null);
configReq.setProperties(configReqProps);
expect(clusterRequest.getDesiredConfig()).andReturn(ImmutableList.of(configReq)).anyTimes();
expect(clusters.getClusterById(1L)).andReturn(cluster).anyTimes();
expect(cluster.getClusterName()).andReturn("clusterOld").anyTimes();
expect(cluster.getConfigPropertiesTypes(anyObject(String.class))).andReturn(Maps.>newHashMap()).anyTimes();
expect(cluster.getDesiredConfigByType(anyObject(String.class))).andReturn(new ConfigImpl("config-type"){
@Override public Map> getPropertiesAttributes(){
return Maps.newHashMap();
}
@Override public Map getProperties(){
return configReqProps;
}
}
).anyTimes();
cluster.addSessionAttributes(anyObject(Map.class));
expectLastCall().once();
cluster.setClusterName("clusterNew");
expectLastCall();
replay(actionManager,cluster,clusters,injector,clusterRequest,sessionManager);
AmbariManagementController controller=new AmbariManagementControllerImpl(actionManager,clusters,injector);
controller.updateClusters(setRequests,null);
assertSame(controller,controllerCapture.getValue());
verify(actionManager,cluster,clusters,injector,clusterRequest,sessionManager);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier singletonMap("host",null));
expect(ambariMetaInfo.getService("stack","1.0","service")).andReturn(serviceInfo);
replay(injector,cluster,service,component,serviceInfo,compInfo,ambariMetaInfo,stackId);
AmbariManagementControllerImpl controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
ServiceComponent resultComponent=controller.getClientComponentForRunningAction(cluster,service);
assertNotNull(resultComponent);
assertEquals(component,resultComponent);
verify(injector,cluster,service,component,serviceInfo,compInfo,ambariMetaInfo,stackId);
}
InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
Cluster cluster=createNiceMock(Cluster.class);
final Host host=createNiceMock(Host.class);
Service service=createNiceMock(Service.class);
Service service2=createNiceMock(Service.class);
ServiceComponent component=createNiceMock(ServiceComponent.class);
ServiceComponent component2=createNiceMock(ServiceComponent.class);
ServiceComponent component3=createNiceMock(ServiceComponent.class);
final ServiceComponentHost componentHost1=createNiceMock(ServiceComponentHost.class);
final ServiceComponentHost componentHost2=createNiceMock(ServiceComponentHost.class);
ServiceComponentHostResponse response1=createNiceMock(ServiceComponentHostResponse.class);
ServiceComponentHostResponse response2=createNiceMock(ServiceComponentHostResponse.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
expect(maintHelper.getEffectiveState(anyObject(ServiceComponentHost.class),anyObject(Host.class))).andReturn(MaintenanceState.OFF).anyTimes();
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1","host1",null);
ServiceComponentHostRequest request2=new ServiceComponentHostRequest("cluster1",null,"component2","host1",null);
ServiceComponentHostRequest request3=new ServiceComponentHostRequest("cluster1",null,"component3","host1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster).times(3);
expect(clusters.getClustersForHost("host1")).andReturn(Collections.singleton(cluster)).anyTimes();
expect(clusters.getHostsForCluster((String)anyObject())).andReturn(new HashMap(){
{
put("host1",host);
}
}
).anyTimes();
expect(cluster.getDesiredStackVersion()).andReturn(stack).anyTimes();
expect(stack.getStackName()).andReturn("stackName").anyTimes();
expect(stack.getStackVersion()).andReturn("stackVersion").anyTimes();
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component1")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component1")).andReturn(component);
expect(component.getName()).andReturn("component1");
expect(component.getServiceComponentHosts()).andReturn(new HashMap(){
{
put("host1",componentHost1);
}
}
);
expect(componentHost1.convertToResponse()).andReturn(response1);
expect(componentHost1.getHostName()).andReturn("host1");
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component2")).andReturn("service2");
expect(cluster.getService("service2")).andReturn(service2);
expect(service2.getServiceComponent("component2")).andThrow(new ServiceComponentNotFoundException("cluster1","service2","component2"));
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component3")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component3")).andReturn(component3);
expect(component3.getName()).andReturn("component3");
expect(component3.getServiceComponentHosts()).andReturn(new HashMap(){
{
put("host1",componentHost2);
}
}
);
expect(componentHost2.convertToResponse()).andReturn(response2);
expect(componentHost2.getHostName()).andReturn("host1");
replay(maintHelper,injector,clusters,cluster,host,stack,ambariMetaInfo,service,service2,component,component2,component3,componentHost1,componentHost2,response1,response2);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
Set setResponses=controller.getHostComponents(setRequests);
assertSame(controller,controllerCapture.getValue());
assertEquals(2,setResponses.size());
assertTrue(setResponses.contains(response1));
assertTrue(setResponses.contains(response2));
verify(injector,clusters,cluster,host,stack,ambariMetaInfo,service,service2,component,component2,component3,componentHost1,componentHost2,response1,response2);
}
InternalCallVerifier IdentityVerifier controllerCapture=new Capture();
Injector injector=createStrictMock(Injector.class);
Cluster cluster=createNiceMock(Cluster.class);
ActionManager actionManager=createNiceMock(ActionManager.class);
ClusterRequest clusterRequest=createNiceMock(ClusterRequest.class);
Set setRequests=Collections.singleton(clusterRequest);
KerberosHelper kerberosHelper=createStrictMock(KerberosHelper.class);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null);
expect(injector.getInstance(KerberosHelper.class)).andReturn(kerberosHelper);
expect(clusterRequest.getClusterName()).andReturn("clusterNew").times(3);
expect(clusterRequest.getClusterId()).andReturn(1L).times(6);
expect(clusters.getClusterById(1L)).andReturn(cluster).times(2);
expect(cluster.getClusterName()).andReturn("clusterOld").times(1);
cluster.addSessionAttributes(anyObject(Map.class));
expectLastCall().once();
cluster.setClusterName("clusterNew");
expectLastCall();
replay(actionManager,cluster,clusters,injector,clusterRequest,sessionManager);
AmbariManagementController controller=new AmbariManagementControllerImpl(actionManager,clusters,injector);
controller.updateClusters(setRequests,null);
assertSame(controller,controllerCapture.getValue());
verify(actionManager,cluster,clusters,injector,clusterRequest,sessionManager);
}
InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
StackId stack=createNiceMock(StackId.class);
Cluster cluster=createNiceMock(Cluster.class);
Service service=createNiceMock(Service.class);
ServiceComponent component=createNiceMock(ServiceComponent.class);
ServiceComponentHost componentHost1=createNiceMock(ServiceComponentHost.class);
ServiceComponentHost componentHost2=createNiceMock(ServiceComponentHost.class);
ServiceComponentHostResponse response1=createNiceMock(ServiceComponentHostResponse.class);
ServiceComponentHostResponse response2=createNiceMock(ServiceComponentHostResponse.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
expect(maintHelper.getEffectiveState(anyObject(ServiceComponentHost.class),anyObject(Host.class))).andReturn(MaintenanceState.OFF).anyTimes();
ServiceComponentHostRequest request1=new ServiceComponentHostRequest("cluster1",null,"component1",null,null);
Set setRequests=new HashSet();
setRequests.add(request1);
Map mapHostComponents=new HashMap();
mapHostComponents.put("foo",componentHost1);
mapHostComponents.put("bar",componentHost2);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(clusters.getHostsForCluster((String)anyObject())).andReturn(new HashMap(){
{
put("host1",createNiceMock(Host.class));
}
}
).anyTimes();
expect(cluster.getDesiredStackVersion()).andReturn(stack);
expect(stack.getStackName()).andReturn("stackName");
expect(stack.getStackVersion()).andReturn("stackVersion");
expect(ambariMetaInfo.getComponentToService("stackName","stackVersion","component1")).andReturn("service1");
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component1")).andReturn(component);
expect(component.getName()).andReturn("component1").anyTimes();
expect(component.getServiceComponentHosts()).andReturn(mapHostComponents);
expect(componentHost1.convertToResponse()).andReturn(response1);
expect(componentHost2.convertToResponse()).andReturn(response2);
expect(componentHost1.getHostName()).andReturn("host1");
expect(componentHost2.getHostName()).andReturn("host1");
replay(maintHelper,injector,clusters,cluster,response1,response2,stack,ambariMetaInfo,service,component,componentHost1,componentHost2);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
setAmbariMetaInfo(ambariMetaInfo,controller);
Set setResponses=controller.getHostComponents(setRequests);
assertSame(controller,controllerCapture.getValue());
assertEquals(2,setResponses.size());
assertTrue(setResponses.contains(response1));
assertTrue(setResponses.contains(response2));
verify(injector,clusters,cluster,response1,response2,stack,ambariMetaInfo,service,component,componentHost1,componentHost2);
}
Class: org.apache.ambari.server.controller.AmbariManagementControllerTest APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier (){
{
add("h1");
add("h2");
}
}
,"centos5");
setupClusterWithHosts("c2","HDP-0.2",new ArrayList(){
{
add("h3");
}
}
,"centos5");
clusters.addHost("h4");
setOsFamily(clusters.getHost("h4"),"redhat","5.9");
clusters.getHost("h4").persist();
Map attrs=new HashMap();
attrs.put("a1","b1");
clusters.getHost("h3").setHostAttributes(attrs);
attrs.put("a2","b2");
clusters.getHost("h4").setHostAttributes(attrs);
HostRequest r=new HostRequest(null,null,null);
Set resps=HostResourceProviderTest.getHosts(controller,Collections.singleton(r));
Assert.assertEquals(4,resps.size());
Set foundHosts=new HashSet();
for ( HostResponse resp : resps) {
foundHosts.add(resp.getHostname());
if (resp.getHostname().equals("h1")) {
Assert.assertEquals("c1",resp.getClusterName());
Assert.assertEquals(2,resp.getHostAttributes().size());
}
else if (resp.getHostname().equals("h2")) {
Assert.assertEquals("c1",resp.getClusterName());
Assert.assertEquals(2,resp.getHostAttributes().size());
}
else if (resp.getHostname().equals("h3")) {
Assert.assertEquals("c2",resp.getClusterName());
Assert.assertEquals(3,resp.getHostAttributes().size());
}
else if (resp.getHostname().equals("h4")) {
Assert.assertEquals("",resp.getClusterName());
Assert.assertEquals(4,resp.getHostAttributes().size());
}
else {
fail("Found invalid host");
}
}
Assert.assertEquals(4,foundHosts.size());
r=new HostRequest("h1",null,null);
resps=HostResourceProviderTest.getHosts(controller,Collections.singleton(r));
Assert.assertEquals(1,resps.size());
HostResponse resp=resps.iterator().next();
Assert.assertEquals("h1",resp.getHostname());
Assert.assertEquals("c1",resp.getClusterName());
Assert.assertEquals(2,resp.getHostAttributes().size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier r=ServiceResourceProviderTest.getServices(controller,Collections.singleton(req));
Assert.assertEquals(1,r.size());
ServiceResponse resp=r.iterator().next();
Assert.assertEquals(serviceName,resp.getServiceName());
Assert.assertEquals(clusterName,resp.getClusterName());
Assert.assertEquals(State.INIT.toString(),resp.getDesiredState());
Assert.assertEquals("HDP-0.1",resp.getDesiredStackVersion());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1, cr2;
cr1=new ConfigurationRequest(clusterName,"core-site","version1",configs,null);
cr2=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
ClusterRequest crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr2));
controller.updateClusters(Collections.singleton(crReq),null);
installService(clusterName,serviceName,false,false);
ExecutionCommand ec=controller.getExecutionCommand(cluster,s1.getServiceComponent("NAMENODE").getServiceComponentHost("h1"),RoleCommand.START);
assertEquals("1-0",ec.getCommandId());
assertEquals("foo1",ec.getClusterName());
Map> configurations=ec.getConfigurations();
assertNotNull(configurations);
assertEquals(2,configurations.size());
assertTrue(configurations.containsKey("hdfs-site"));
assertTrue(configurations.containsKey("core-site"));
assertTrue(ec.getConfigurationAttributes().containsKey("hdfs-site"));
assertTrue(ec.getConfigurationAttributes().containsKey("core-site"));
assertTrue(ec.getCommandParams().containsKey("max_duration_for_retries"));
assertEquals("0",ec.getCommandParams().get("max_duration_for_retries"));
assertTrue(ec.getCommandParams().containsKey("command_retry_enabled"));
assertEquals("false",ec.getCommandParams().get("command_retry_enabled"));
Map> chInfo=ec.getClusterHostInfo();
assertTrue(chInfo.containsKey("namenode_host"));
}
BranchVerifier InternalCallVerifier EqualityVerifier IgnoredMethod HybridVerifier configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1, cr2;
cr1=new ConfigurationRequest(clusterName,"core-site","version1",configs,null);
cr2=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
controller.createConfiguration(cr1);
controller.createConfiguration(cr2);
Map configVersions=new HashMap(){
{
put("core-site","version1");
put("hdfs-site","version1");
}
}
;
ServiceRequest sr=new ServiceRequest(clusterName,serviceName,null);
ServiceResourceProviderTest.updateServices(controller,Collections.singleton(sr),new HashMap(),false,false);
installService(clusterName,serviceName,false,false);
long requestId=startService(clusterName,serviceName,true,false);
Assert.assertEquals(0,clusters.getCluster(clusterName).getDesiredConfigs().size());
List stages=actionDB.getAllStages(requestId);
boolean serviceCheckFound=false;
for ( Stage stage : stages) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.HDFS_SERVICE_CHECK)) {
serviceCheckFound=true;
Assert.assertEquals(2,hrc.getExecutionCommandWrapper().getExecutionCommand().getConfigurationTags().size());
}
}
}
Assert.assertEquals(true,serviceCheckFound);
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier IgnoredMethod HybridVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createCluster(clusterName);
Cluster c=clusters.getCluster(clusterName);
c.setDesiredStackVersion(currentStackId);
createService(clusterName,serviceName,State.INIT);
createServiceComponent(clusterName,serviceName,componentName,null);
addHostToCluster(host1,clusterName);
addHostToCluster(host2,clusterName);
createServiceComponentHost(clusterName,null,componentName,host1,null);
createServiceComponentHost(clusterName,null,componentName,host2,null);
c.getService(serviceName).setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1).setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2).setDesiredState(State.STARTED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1).setState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2).setState(State.STARTED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1).setStackVersion(currentStackId);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2).setStackVersion(currentStackId);
ClusterRequest r=new ClusterRequest(c.getClusterId(),clusterName,"HDP-0.0.1",null);
try {
controller.updateClusters(Collections.singleton(r),mapRequestProps);
fail("Update cluster should fail");
}
catch ( AmbariException e) {
Assert.assertTrue(e.getMessage().contains("must be greater than current version"));
}
r=new ClusterRequest(c.getClusterId(),clusterName,"HDPLocal-1.2.2",null);
try {
controller.updateClusters(Collections.singleton(r),mapRequestProps);
fail("Update cluster should fail");
}
catch ( AmbariException e) {
Assert.assertTrue(e.getMessage().contains("Upgrade not possible between different stacks"));
}
r=new ClusterRequest(c.getClusterId(),clusterName,"HDP-0.2",null);
try {
controller.updateClusters(Collections.singleton(r),mapRequestProps);
fail("Update cluster should fail");
}
catch ( AmbariException e) {
Assert.assertTrue(e.getMessage().contains("Upgrade needs all services to be stopped"));
Assert.assertTrue(e.getMessage().contains(serviceName));
}
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2).setDesiredState(State.INSTALLED);
r=new ClusterRequest(c.getClusterId(),clusterName,"HDP-0.2",null);
try {
controller.updateClusters(Collections.singleton(r),mapRequestProps);
fail("Update cluster should fail");
}
catch ( AmbariException e) {
Assert.assertTrue(e.getMessage().contains("Upgrade needs all services to be stopped"));
Assert.assertTrue(e.getMessage().contains(componentName));
}
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2).setState(State.INSTALLED);
controller.updateClusters(Collections.singleton(r),mapRequestProps);
StackId expectedStackId=new StackId("HDP-0.2");
Assert.assertTrue(expectedStackId.equals(c.getDesiredStackVersion()));
Assert.assertTrue(expectedStackId.equals(c.getService(serviceName).getDesiredStackVersion()));
Assert.assertTrue(expectedStackId.equals(c.getService(serviceName).getServiceComponent(componentName).getDesiredStackVersion()));
Assert.assertTrue(expectedStackId.equals(c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1).getDesiredStackVersion()));
Assert.assertTrue(expectedStackId.equals(c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2).getDesiredStackVersion()));
Assert.assertTrue(currentStackId.equals(c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1).getStackVersion()));
Assert.assertTrue(currentStackId.equals(c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2).getStackVersion()));
ServiceComponent sc=c.getService(serviceName).getServiceComponent(componentName);
Assert.assertEquals(State.UPGRADING,sc.getServiceComponentHost(host1).getState());
Assert.assertEquals(State.UPGRADING,sc.getServiceComponentHost(host2).getState());
try {
controller.updateClusters(Collections.singleton(r),mapRequestProps);
fail("Update cluster should fail");
}
catch ( AmbariException e) {
Assert.assertTrue(e.getMessage().contains("A prior upgrade request with id"));
}
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1).setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2).setDesiredState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host1).setState(State.INSTALLED);
c.getService(serviceName).getServiceComponent(componentName).getServiceComponentHost(host2).setState(State.INSTALLED);
c.setCurrentStackVersion(expectedStackId);
r=new ClusterRequest(c.getClusterId(),clusterName,"",null);
controller.updateClusters(Collections.singleton(r),mapRequestProps);
Assert.assertEquals(State.INSTALLED,sc.getServiceComponentHost(host1).getState());
Assert.assertEquals(State.INSTALLED,sc.getServiceComponentHost(host2).getState());
r=new ClusterRequest(c.getClusterId(),clusterName,null,null);
controller.updateClusters(Collections.singleton(r),mapRequestProps);
Assert.assertEquals(State.INSTALLED,sc.getServiceComponentHost(host1).getState());
Assert.assertEquals(State.INSTALLED,sc.getServiceComponentHost(host2).getState());
r=new ClusterRequest(c.getClusterId(),clusterName,"HDP-0.2",null);
controller.updateClusters(Collections.singleton(r),mapRequestProps);
Assert.assertEquals(State.INSTALLED,sc.getServiceComponentHost(host1).getState());
Assert.assertEquals(State.INSTALLED,sc.getServiceComponentHost(host2).getState());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier set1=new HashSet();
ServiceComponentRequest valid1=new ServiceComponentRequest("c1","HDFS","NAMENODE",null);
ServiceComponentRequest valid2=new ServiceComponentRequest("c1","MAPREDUCE","JOBTRACKER",null);
ServiceComponentRequest valid3=new ServiceComponentRequest("c1","MAPREDUCE","TASKTRACKER",null);
set1.add(valid1);
set1.add(valid2);
set1.add(valid3);
ComponentResourceProviderTest.createComponents(controller,set1);
Assert.assertEquals(1,c1.getService("HDFS").getServiceComponents().size());
Assert.assertEquals(2,c1.getService("MAPREDUCE").getServiceComponents().size());
Assert.assertNotNull(c1.getService("HDFS").getServiceComponent("NAMENODE"));
Assert.assertNotNull(c1.getService("MAPREDUCE").getServiceComponent("JOBTRACKER"));
Assert.assertNotNull(c1.getService("MAPREDUCE").getServiceComponent("TASKTRACKER"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier responses=controller.getStackComponents(Collections.singleton(namenodeRequest));
Assert.assertEquals(1,responses.size());
StackServiceComponentResponse response=responses.iterator().next();
assertNotNull(response.getCustomCommands());
assertEquals(2,response.getCustomCommands().size());
assertEquals("DECOMMISSION",response.getCustomCommands().get(0));
assertEquals("REBALANCEHDFS",response.getCustomCommands().get(1));
StackServiceComponentRequest journalNodeRequest=new StackServiceComponentRequest(STACK_NAME,NEW_STACK_VERSION,SERVICE_NAME,"JOURNALNODE");
responses=controller.getStackComponents(Collections.singleton(journalNodeRequest));
Assert.assertEquals(1,responses.size());
response=responses.iterator().next();
assertNotNull(response.getCustomCommands());
assertEquals(0,response.getCustomCommands().size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier responses=controller.getStackVersions(Collections.singleton(request));
Assert.assertEquals(STACK_VERSIONS_CNT,responses.size());
StackVersionRequest requestWithParams=new StackVersionRequest(STACK_NAME,STACK_VERSION);
Set responsesWithParams=controller.getStackVersions(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( StackVersionResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getStackVersion(),STACK_VERSION);
}
StackVersionRequest invalidRequest=new StackVersionRequest(STACK_NAME,NON_EXT_VALUE);
try {
controller.getStackVersions(Collections.singleton(invalidRequest));
}
catch ( StackAccessException e) {
}
requestWithParams=new StackVersionRequest(STACK_NAME,"2.1.1");
responsesWithParams=controller.getStackVersions(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
StackVersionResponse resp=responsesWithParams.iterator().next();
assertNotNull(resp.getUpgradePacks());
assertEquals(8,resp.getUpgradePacks().size());
assertTrue(resp.getUpgradePacks().contains("upgrade_test"));
}
InternalCallVerifier EqualityVerifier IgnoredMethod HybridVerifier responses=controller.getUsers(Collections.singleton(new UserRequest(null)));
Assert.assertEquals(0,responses.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier responses=controller.getStacks(Collections.singleton(request));
Assert.assertEquals(STACKS_CNT,responses.size());
StackRequest requestWithParams=new StackRequest(STACK_NAME);
Set responsesWithParams=controller.getStacks(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( StackResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getStackName(),STACK_NAME);
}
StackRequest invalidRequest=new StackRequest(NON_EXT_VALUE);
try {
controller.getStacks(Collections.singleton(invalidRequest));
}
catch ( StackAccessException e) {
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier (){
{
add(host1);
add(host2);
}
}
,"centos5");
String serviceName="HDFS";
createService(clusterName,serviceName,null);
String componentName1="NAMENODE";
String componentName2="DATANODE";
String componentName3="HDFS_CLIENT";
createServiceComponent(clusterName,serviceName,componentName1,State.INIT);
createServiceComponent(clusterName,serviceName,componentName2,State.INIT);
createServiceComponent(clusterName,serviceName,componentName3,State.INIT);
createServiceComponentHost(clusterName,serviceName,componentName1,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
installService(clusterName,serviceName,false,false);
Map hdfsConfigs=new HashMap();
hdfsConfigs.put("a","b");
Map> hdfsConfigAttributes=new HashMap>(){
{
put("final",new HashMap(){
{
put("a","true");
}
}
);
}
}
;
ConfigurationRequest cr1=new ConfigurationRequest(clusterName,"hdfs-site","version1",hdfsConfigs,hdfsConfigAttributes);
ClusterRequest crReq1=new ClusterRequest(clusterId,clusterName,null,null);
crReq1.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq1),null);
startService(clusterName,serviceName,false,false);
HashMap> actualConfig=new HashMap>(){
{
put("hdfs-site",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
;
HashMap> actualConfigOld=new HashMap>(){
{
put("hdfs-site",new HashMap(){
{
put("tag","version0");
}
}
);
}
}
;
Service s1=clusters.getCluster(clusterName).getService(serviceName);
s1.getServiceComponent(componentName1).getServiceComponentHost(host1).updateActualConfigs(actualConfig);
s1.getServiceComponent(componentName2).getServiceComponentHost(host1).updateActualConfigs(actualConfig);
s1.getServiceComponent(componentName3).getServiceComponentHost(host1).updateActualConfigs(actualConfigOld);
s1.getServiceComponent(componentName2).getServiceComponentHost(host2).updateActualConfigs(actualConfigOld);
s1.getServiceComponent(componentName3).getServiceComponentHost(host2).updateActualConfigs(actualConfig);
ServiceComponentHostRequest r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
Set resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(5,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
r.setStaleConfig("true");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
r.setStaleConfig("false");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(3,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,host1,null);
r.setStaleConfig("false");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,host2,null);
r.setStaleConfig("true");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
}
InternalCallVerifier BooleanVerifier UtilityVerifier InternalCallVerifier IdentityVerifier HybridVerifier controllerCapture=new Capture();
Clusters clusters=createNiceMock(Clusters.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
Cluster cluster=createNiceMock(Cluster.class);
ServiceRequest request1=new ServiceRequest("cluster1","service1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createStrictMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(cluster.getService("service1")).andThrow(new ServiceNotFoundException("custer1","service1"));
replay(maintHelper,injector,clusters,cluster);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
try {
ServiceResourceProviderTest.getServices(controller,setRequests);
fail("expected ServiceNotFoundException");
}
catch ( ServiceNotFoundException e) {
}
assertSame(controller,controllerCapture.getValue());
verify(injector,clusters,cluster);
}
APIUtilityVerifier InternalCallVerifier NullVerifier (){
{
put("a","b");
}
}
,null);
cr.setDesiredConfig(Collections.singletonList(configRequest));
cr.setClusterId(CLUSTER_ID);
amc.updateClusters(Collections.singleton(cr),new HashMap());
Set hrs=new HashSet();
hrs.add(new HostRequest(HOST1,CLUSTER_NAME,null));
HostResourceProviderTest.createHosts(amc,hrs);
Set serviceRequests=new HashSet();
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"HDFS",null));
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"MAPREDUCE2",null));
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"YARN",null));
ServiceResourceProviderTest.createServices(amc,serviceRequests);
Set serviceComponentRequests=new HashSet();
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"HDFS","NAMENODE",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"HDFS","SECONDARY_NAMENODE",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"HDFS","DATANODE",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"MAPREDUCE2","HISTORYSERVER",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"YARN","RESOURCEMANAGER",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"YARN","NODEMANAGER",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"HDFS","HDFS_CLIENT",null));
ComponentResourceProviderTest.createComponents(amc,serviceComponentRequests);
Set componentHostRequests=new HashSet();
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"DATANODE",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"NAMENODE",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"SECONDARY_NAMENODE",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"HISTORYSERVER",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"RESOURCEMANAGER",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"NODEMANAGER",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"HDFS_CLIENT",HOST1,null));
amc.createHostComponents(componentHostRequests);
RequestResourceFilter resourceFilter=new RequestResourceFilter("HDFS",null,null);
ExecuteActionRequest ar=new ExecuteActionRequest(CLUSTER_NAME,Role.HDFS_SERVICE_CHECK.name(),null,false);
ar.getResourceFilters().add(resourceFilter);
amc.createAction(ar,null);
amc.deleteCluster(cr);
assertNotNull(clusters.getHost(HOST1));
assertNotNull(clusters.getHost(HOST2));
HostDAO dao=injector.getInstance(HostDAO.class);
assertNotNull(dao.findByName(HOST1));
assertNotNull(dao.findByName(HOST2));
}
finally {
injector.getInstance(PersistService.class).stop();
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier (){
{
add(hostName1);
}
}
,clusterName);
List stages=new ArrayList();
stages.add(stageFactory.createNew(requestId1,"/a1",clusterName,1L,context,CLUSTER_HOST_INFO,"",""));
stages.get(0).setStageId(1);
stages.get(0).addHostRoleExecutionCommand(hostName1,Role.HBASE_MASTER,RoleCommand.START,new ServiceComponentHostStartEvent(Role.HBASE_MASTER.toString(),hostName1,System.currentTimeMillis()),clusterName,"HBASE",false,false);
stages.add(stageFactory.createNew(requestId1,"/a2",clusterName,1L,context,CLUSTER_HOST_INFO,"",""));
stages.get(1).setStageId(2);
stages.get(1).addHostRoleExecutionCommand(hostName1,Role.HBASE_CLIENT,RoleCommand.START,new ServiceComponentHostStartEvent(Role.HBASE_CLIENT.toString(),hostName1,System.currentTimeMillis()),clusterName,"HBASE",false,false);
stages.add(stageFactory.createNew(requestId1,"/a3",clusterName,1L,context,CLUSTER_HOST_INFO,"",""));
stages.get(2).setStageId(3);
stages.get(2).addHostRoleExecutionCommand(hostName1,Role.HBASE_CLIENT,RoleCommand.START,new ServiceComponentHostStartEvent(Role.HBASE_CLIENT.toString(),hostName1,System.currentTimeMillis()),clusterName,"HBASE",false,false);
Request request=new Request(stages,clusters);
actionDB.persistActions(request);
stages.clear();
stages.add(stageFactory.createNew(requestId2,"/a4",clusterName,1L,context,CLUSTER_HOST_INFO,"",""));
stages.get(0).setStageId(4);
stages.get(0).addHostRoleExecutionCommand(hostName1,Role.HBASE_CLIENT,RoleCommand.START,new ServiceComponentHostStartEvent(Role.HBASE_CLIENT.toString(),hostName1,System.currentTimeMillis()),clusterName,"HBASE",false,false);
stages.add(stageFactory.createNew(requestId2,"/a5",clusterName,1L,context,CLUSTER_HOST_INFO,"",""));
stages.get(1).setStageId(5);
stages.get(1).addHostRoleExecutionCommand(hostName1,Role.HBASE_CLIENT,RoleCommand.START,new ServiceComponentHostStartEvent(Role.HBASE_CLIENT.toString(),hostName1,System.currentTimeMillis()),clusterName,"HBASE",false,false);
request=new Request(stages,clusters);
actionDB.persistActions(request);
ServiceComponentHostServerActionEvent serviceComponentHostServerActionEvent=new ServiceComponentHostServerActionEvent(Role.AMBARI_SERVER_ACTION.toString(),null,System.currentTimeMillis());
stages.clear();
stages.add(stageFactory.createNew(requestId3,"/a6",clusterName,1L,context,CLUSTER_HOST_INFO,"",""));
stages.get(0).setStageId(6);
stages.get(0).addServerActionCommand("some.action.class.name",null,Role.AMBARI_SERVER_ACTION,RoleCommand.EXECUTE,clusterName,serviceComponentHostServerActionEvent,null,null,null,null,false,false);
assertEquals("_internal_ambari",stages.get(0).getOrderedHostRoleCommands().get(0).getHostName());
request=new Request(stages,clusters);
actionDB.persistActions(request);
org.apache.ambari.server.controller.spi.Request spiRequest=PropertyHelper.getReadRequest(TaskResourceProvider.TASK_CLUSTER_NAME_PROPERTY_ID,TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID,TaskResourceProvider.TASK_STAGE_ID_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID).equals(requestId1).toPredicate();
List entities=hostRoleCommandDAO.findAll(spiRequest,predicate);
Assert.assertEquals(3,entities.size());
predicate=new PredicateBuilder().property(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID).equals(requestId1).and().property(TaskResourceProvider.TASK_ID_PROPERTY_ID).equals(2L).toPredicate();
entities=hostRoleCommandDAO.findAll(spiRequest,predicate);
Assert.assertEquals(1,entities.size());
predicate=new PredicateBuilder().property(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID).equals(requestId2).toPredicate();
entities=hostRoleCommandDAO.findAll(spiRequest,predicate);
Assert.assertEquals(2,entities.size());
predicate=new PredicateBuilder().property(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID).equals(requestId1).and().property(TaskResourceProvider.TASK_ID_PROPERTY_ID).equals(2L).or().property(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID).equals(requestId2).toPredicate();
entities=hostRoleCommandDAO.findAll(spiRequest,predicate);
Assert.assertEquals(3,entities.size());
}
APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (){
{
add(host1);
add(host2);
}
}
,"centos5");
String serviceName="HDFS";
createService(clusterName,serviceName,null);
String componentName1="NAMENODE";
String componentName2="DATANODE";
String componentName3="HDFS_CLIENT";
createServiceComponent(clusterName,serviceName,componentName1,State.INIT);
createServiceComponent(clusterName,serviceName,componentName2,State.INIT);
createServiceComponent(clusterName,serviceName,componentName3,State.INIT);
createServiceComponentHost(clusterName,serviceName,componentName1,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
installService(clusterName,serviceName,false,false);
ClusterRequest crReq;
ConfigurationRequest cr;
cr=new ConfigurationRequest(clusterName,"hdfs-site","version1",new HashMap(){
{
put("test.password","first");
put("test.password.empty","");
}
}
,new HashMap>());
crReq=new ClusterRequest(clusterId,clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr));
controller.updateClusters(Collections.singleton(crReq),null);
cr=new ConfigurationRequest(clusterName,"hdfs-site","version2",new HashMap(){
{
put("test.password","SECRET:hdfs-site:1:test.password");
put("new","new");
}
}
,new HashMap>());
crReq=new ClusterRequest(clusterId,clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr));
controller.updateClusters(Collections.singleton(crReq),null);
cr=new ConfigurationRequest(clusterName,"hdfs-site","version3",new HashMap(){
{
put("test.password","brandNewPassword");
}
}
,new HashMap>());
crReq=new ClusterRequest(clusterId,clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr));
controller.updateClusters(Collections.singleton(crReq),null);
cr=new ConfigurationRequest(clusterName,"hdfs-site","version3",new HashMap(){
{
put("test.password","SECRET:hdfs-site:666:test.password");
}
}
,new HashMap>());
crReq=new ClusterRequest(clusterId,clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr));
try {
controller.updateClusters(Collections.singleton(crReq),null);
fail("Request need to be failed with wrong secret reference");
}
catch ( AmbariException e) {
}
cr=new ConfigurationRequest(clusterName,"hdfs-site","version4",new HashMap(){
{
put("foo","bar");
}
}
,new HashMap>());
crReq=new ClusterRequest(clusterId,clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr));
controller.updateClusters(Collections.singleton(crReq),null);
cr=new ConfigurationRequest(clusterName,"hdfs-site","version5",new HashMap(){
{
put("test.password","SECRET:hdfs-site:4:test.password");
put("new","new");
}
}
,new HashMap>());
crReq=new ClusterRequest(clusterId,clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr));
try {
controller.updateClusters(Collections.singleton(crReq),null);
fail("Request need to be failed with wrong secret reference");
}
catch ( AmbariException e) {
assertEquals("Error when parsing secret reference. Cluster: foo1 ConfigType: hdfs-site ConfigVersion: 4 does not contain property 'test.password'",e.getMessage());
}
cl.getAllConfigs();
assertEquals(cl.getAllConfigs().size(),4);
Config v1=cl.getConfigByVersion("hdfs-site",1l);
Config v2=cl.getConfigByVersion("hdfs-site",2l);
Config v3=cl.getConfigByVersion("hdfs-site",3l);
Config v4=cl.getConfigByVersion("hdfs-site",4l);
assertEquals(v1.getProperties().get("test.password"),"first");
assertEquals(v2.getProperties().get("test.password"),"first");
assertEquals(v3.getProperties().get("test.password"),"brandNewPassword");
assertFalse(v4.getProperties().containsKey("test.password"));
final ConfigurationRequest configRequest=new ConfigurationRequest(clusterName,"hdfs-site",null,null,null);
configRequest.setIncludeProperties(true);
Set requestedConfigs=controller.getConfigurations(new HashSet(){
{
add(configRequest);
}
}
);
for ( ConfigurationResponse resp : requestedConfigs) {
String secretName="SECRET:hdfs-site:" + resp.getVersion().toString() + ":test.password";
if (resp.getConfigs().containsKey("test.password")) {
assertEquals(resp.getConfigs().get("test.password"),secretName);
}
if (resp.getConfigs().containsKey("test.password.empty")) {
assertEquals(resp.getConfigs().get("test.password.empty"),"");
}
}
}
UtilityVerifier InternalCallVerifier NullVerifier HybridVerifier hostNames=new HashSet();
hostNames.add("h1");
hostNames.add("h2");
ClusterRequest r=new ClusterRequest(null,"c1","HDP-0.1",hostNames);
try {
controller.createCluster(r);
fail("Expected create cluster to fail for invalid hosts");
}
catch ( Exception e) {
}
try {
clusters.getCluster("c1");
fail("Expected to fail for non created cluster");
}
catch ( ClusterNotFoundException e) {
}
clusters.addHost("h1");
clusters.addHost("h2");
setOsFamily(clusters.getHost("h1"),"redhat","6.3");
setOsFamily(clusters.getHost("h2"),"redhat","6.3");
clusters.getHost("h1").persist();
clusters.getHost("h2").persist();
controller.createCluster(r);
Assert.assertNotNull(clusters.getCluster("c1"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
add("h1");
}
}
,"centos5");
Service s1=serviceFactory.createNew(c1,"HDFS");
c1.addService(s1);
s1.persist();
ServiceComponent sc1=serviceComponentFactory.createNew(s1,"DATANODE");
s1.addServiceComponent(sc1);
sc1.setDesiredState(State.UNINSTALLED);
sc1.persist();
ServiceComponentHost sch1=serviceComponentHostFactory.createNew(sc1,"h1");
sc1.addServiceComponentHost(sch1);
sch1.setDesiredState(State.INSTALLED);
sch1.setState(State.INSTALLING);
sch1.setDesiredStackVersion(new StackId("HDP-1.2.0"));
sch1.setStackVersion(new StackId("HDP-0.1"));
sch1.persist();
sch1.updateActualConfigs(new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
);
ServiceComponentHostRequest r=new ServiceComponentHostRequest(c1.getClusterName(),null,null,null,null);
Set resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
ServiceComponentHostResponse resp=resps.iterator().next();
Assert.assertEquals(c1.getClusterName(),resp.getClusterName());
Assert.assertEquals(sc1.getName(),resp.getComponentName());
Assert.assertEquals(s1.getName(),resp.getServiceName());
Assert.assertEquals(sch1.getHostName(),resp.getHostname());
Assert.assertEquals(sch1.getDesiredState().toString(),resp.getDesiredState());
Assert.assertEquals(sch1.getState().toString(),resp.getLiveState());
Assert.assertEquals(sch1.getStackVersion().getStackId(),resp.getStackVersion());
Assert.assertNotNull(resp.getActualConfigs());
Assert.assertEquals(1,resp.getActualConfigs().size());
}
InternalCallVerifier BooleanVerifier APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier response=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2,response.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
Clusters clusters=createNiceMock(Clusters.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
Cluster cluster=createNiceMock(Cluster.class);
Service service=createNiceMock(Service.class);
ServiceResponse response=createNiceMock(ServiceResponse.class);
ServiceRequest request1=new ServiceRequest("cluster1","service1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createStrictMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(cluster.getService("service1")).andReturn(service);
expect(service.convertToResponse()).andReturn(response);
replay(maintHelper,injector,clusters,cluster,service,response);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
Set setResponses=ServiceResourceProviderTest.getServices(controller,setRequests);
assertSame(controller,controllerCapture.getValue());
assertEquals(1,setResponses.size());
assertTrue(setResponses.contains(response));
verify(injector,clusters,cluster,service,response);
}
UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hostComponents=cluster.getService(serviceName).getServiceComponent(componentName1).getServiceComponentHosts();
for ( Map.Entry entry : hostComponents.entrySet()) {
ServiceComponentHost cHost=entry.getValue();
cHost.handleEvent(new ServiceComponentHostInstallEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis(),cluster.getDesiredStackVersion().getStackId()));
cHost.handleEvent(new ServiceComponentHostOpSucceededEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis()));
}
hostComponents=cluster.getService(serviceName).getServiceComponent(componentName2).getServiceComponentHosts();
for ( Map.Entry entry : hostComponents.entrySet()) {
ServiceComponentHost cHost=entry.getValue();
cHost.handleEvent(new ServiceComponentHostInstallEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis(),cluster.getDesiredStackVersion().getStackId()));
cHost.handleEvent(new ServiceComponentHostOpSucceededEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis()));
}
Set requests=new HashSet();
requests.clear();
requests.add(new HostRequest(host1,clusterName,null));
try {
HostResourceProviderTest.deleteHosts(controller,requests);
fail("Expect failure deleting hosts when components exist and have not been deleted.");
}
catch ( Exception e) {
}
Set schRequests=new HashSet();
schRequests.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,"DISABLED"));
schRequests.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName2,host1,"DISABLED"));
updateHostComponents(schRequests,new HashMap(),false);
schRequests.clear();
schRequests.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,null));
schRequests.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName2,host1,null));
schRequests.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName3,host1,null));
controller.deleteHostComponents(schRequests);
Assert.assertEquals(0,cluster.getServiceComponentHosts(host1).size());
requests.clear();
requests.add(new HostRequest(host1,null,null));
try {
HostResourceProviderTest.deleteHosts(controller,requests);
}
catch ( Exception e) {
fail("Did not expect an error deleting the host from the cluster. Error: " + e.getMessage());
}
Assert.assertFalse(clusters.getHostsForCluster(clusterName).containsKey(host1));
Assert.assertFalse(clusters.getClustersForHost(host1).contains(cluster));
requests.clear();
requests.add(new HostRequest(host2,clusterName,null));
try {
HostResourceProviderTest.deleteHosts(controller,requests);
}
catch ( Exception e) {
fail("Did not expect an error deleting the host from the cluster. Error: " + e.getMessage());
}
Assert.assertFalse(clusters.getHostsForCluster(clusterName).containsKey(host2));
Assert.assertFalse(clusters.getClustersForHost(host2).contains(cluster));
requests.clear();
requests.add(new HostRequest(host1,null,null));
try {
HostResourceProviderTest.deleteHosts(controller,requests);
Assert.fail("Expected a HostNotFoundException trying to remove a host that was already deleted.");
}
catch ( HostNotFoundException e) {
}
try {
clusters.getHost(host1);
Assert.fail("Expected a HostNotFoundException.");
}
catch ( HostNotFoundException e) {
}
requests.clear();
requests.add(new HostRequest(host3,null,null));
try {
HostResourceProviderTest.deleteHosts(controller,requests);
Assert.fail("Expected a HostNotFoundException trying to remove a host that was never added.");
}
catch ( HostNotFoundException e) {
}
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hostComponents=cluster.getService(serviceName).getServiceComponent(componentName1).getServiceComponentHosts();
for ( Map.Entry entry : hostComponents.entrySet()) {
ServiceComponentHost cHost=entry.getValue();
cHost.handleEvent(new ServiceComponentHostInstallEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis(),cluster.getDesiredStackVersion().getStackId()));
cHost.handleEvent(new ServiceComponentHostOpSucceededEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis()));
}
hostComponents=cluster.getService(serviceName).getServiceComponent(componentName2).getServiceComponentHosts();
for ( Map.Entry entry : hostComponents.entrySet()) {
ServiceComponentHost cHost=entry.getValue();
cHost.handleEvent(new ServiceComponentHostInstallEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis(),cluster.getDesiredStackVersion().getStackId()));
cHost.handleEvent(new ServiceComponentHostOpSucceededEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis()));
}
ServiceComponentHost sch=cluster.getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host1);
Assert.assertNotNull(sch);
sch.handleEvent(new ServiceComponentHostStartEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis()));
sch.handleEvent(new ServiceComponentHostStartedEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis()));
Set schRequests=new HashSet();
schRequests.add(new ServiceComponentHostRequest(clusterName,null,null,host1,null));
try {
controller.deleteHostComponents(schRequests);
fail("Expected exception while deleting all host components.");
}
catch ( AmbariException e) {
}
Assert.assertEquals(3,cluster.getServiceComponentHosts(host1).size());
sch.handleEvent(new ServiceComponentHostStopEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis()));
sch.handleEvent(new ServiceComponentHostStoppedEvent(sch.getServiceComponentName(),sch.getHostName(),System.currentTimeMillis()));
schRequests.clear();
schRequests.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,"DISABLED"));
updateHostComponents(schRequests,new HashMap(),false);
schRequests.clear();
schRequests.add(new ServiceComponentHostRequest(clusterName,null,null,host1,null));
controller.deleteHostComponents(schRequests);
Assert.assertEquals(0,cluster.getServiceComponentHosts(host1).size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createServiceComponentHost(clusterName,null,componentName1,host1,null);
createServiceComponentHost(clusterName,null,componentName1,host2,null);
ServiceRequest r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
Set requests=new HashSet();
requests.add(r);
RequestStatusResponse trackAction=ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertEquals(State.INSTALLED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
Assert.assertEquals(State.INSTALLED,sc.getDesiredState());
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
Assert.assertEquals(State.INIT,sch.getState());
}
}
List taskStatuses=trackAction.getTasks();
Assert.assertEquals(2,taskStatuses.size());
List stages=actionDB.getAllStages(trackAction.getRequestId());
Assert.assertEquals(1,stages.size());
Assert.assertEquals("Called from a test",stages.get(0).getRequestContext());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
r=new ServiceRequest(clusterName,serviceName,State.STARTED.toString());
requests.clear();
requests.add(r);
injector.getInstance(ActionMetadata.class).addServiceCheckAction("PIG");
trackAction=ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertNotNull(trackAction);
Assert.assertEquals(State.INSTALLED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
Assert.assertEquals(State.INSTALLED,sc.getDesiredState());
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
Assert.assertEquals(State.INSTALLED,sch.getState());
}
}
stages=actionDB.getAllStages(trackAction.getRequestId());
for ( Stage s : stages) {
LOG.info("Stage dump : " + s.toString());
}
Assert.assertEquals(1,stages.size());
taskStatuses=trackAction.getTasks();
Assert.assertEquals(1,taskStatuses.size());
Assert.assertEquals(Role.PIG_SERVICE_CHECK.toString(),taskStatuses.get(0).getRole());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createServiceComponent(clusterName,serviceName,componentName1,State.INIT);
createServiceComponent(clusterName,serviceName,componentName2,State.INIT);
createServiceComponent(clusterName,serviceName,componentName3,State.INIT);
String host1="h1";
String host2="h2";
addHostToCluster(host1,clusterName);
addHostToCluster(host2,clusterName);
createServiceComponentHost(clusterName,null,componentName1,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
ServiceRequest r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
Set requests=new HashSet();
requests.add(r);
ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertEquals(State.INSTALLED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
Map configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1, cr2, cr3;
cr1=new ConfigurationRequest(clusterName,"core-site","version1",configs,null);
cr2=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
cr3=new ConfigurationRequest(clusterName,"core-site","version122",configs,null);
controller.createConfiguration(cr1);
controller.createConfiguration(cr2);
controller.createConfiguration(cr3);
Cluster cluster=clusters.getCluster(clusterName);
Service s=cluster.getService(serviceName);
ServiceComponent sc1=s.getServiceComponent(componentName1);
ServiceComponent sc2=s.getServiceComponent(componentName2);
ServiceComponentHost sch1=sc1.getServiceComponentHost(host1);
Set schReqs=new HashSet();
Set scReqs=new HashSet();
Set sReqs=new HashSet();
Map configVersions=new HashMap();
configVersions.clear();
configVersions.put("core-site","version1");
configVersions.put("hdfs-site","version1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,null));
Assert.assertNull(updateHostComponents(schReqs,Collections.emptyMap(),true));
configVersions.clear();
configVersions.put("core-site","version122");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,null));
Assert.assertNull(updateHostComponents(schReqs,Collections.emptyMap(),true));
entityManager.clear();
configVersions.clear();
configVersions.put("core-site","version1");
configVersions.put("hdfs-site","version1");
scReqs.add(new ServiceComponentRequest(clusterName,serviceName,componentName2,null));
Assert.assertNull(ComponentResourceProviderTest.updateComponents(controller,scReqs,Collections.emptyMap(),true));
scReqs.add(new ServiceComponentRequest(clusterName,serviceName,componentName1,null));
Assert.assertNull(ComponentResourceProviderTest.updateComponents(controller,scReqs,Collections.emptyMap(),true));
configVersions.clear();
configVersions.put("core-site","version122");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName,serviceName,componentName2,null));
Assert.assertNull(ComponentResourceProviderTest.updateComponents(controller,scReqs,Collections.emptyMap(),true));
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName,serviceName,componentName1,null));
Assert.assertNull(ComponentResourceProviderTest.updateComponents(controller,scReqs,Collections.emptyMap(),true));
entityManager.clear();
configVersions.clear();
configVersions.put("core-site","version1");
configVersions.put("hdfs-site","version1");
sReqs.clear();
sReqs.add(new ServiceRequest(clusterName,serviceName,null));
Assert.assertNull(ServiceResourceProviderTest.updateServices(controller,sReqs,mapRequestProps,true,false));
configVersions.clear();
configVersions.put("core-site","version122");
sReqs.clear();
sReqs.add(new ServiceRequest(clusterName,serviceName,null));
Assert.assertNull(ServiceResourceProviderTest.updateServices(controller,sReqs,mapRequestProps,true,false));
entityManager.clear();
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier requests=new HashSet();
requests.add(request);
try {
controller.updateRepositories(requests);
Assert.fail("Expected a bad URL to throw an exception");
}
catch ( Exception e) {
assertNotNull(e);
Assert.assertTrue(e.getMessage().contains(badUrl));
}
request.setVerifyBaseUrl(false);
controller.updateRepositories(requests);
Assert.assertEquals(request.getBaseUrl(),repo.getBaseUrl());
requests.clear();
request=new RepositoryRequest(STACK_NAME,STACK_VERSION,OS_TYPE,REPO_ID);
request.setBaseUrl("https://hortonworks.com");
requests.add(request);
controller.updateRepositories(requests);
requests.clear();
request=new RepositoryRequest(STACK_NAME,STACK_VERSION,OS_TYPE,REPO_ID);
request.setBaseUrl("pro://hortonworks.com");
requests.add(request);
try {
controller.updateRepositories(requests);
}
catch ( Exception e) {
assertTrue(e.getMessage().contains("Could not access base url"));
}
requests.clear();
request=new RepositoryRequest(STACK_NAME,STACK_VERSION,OS_TYPE,REPO_ID);
request.setBaseUrl("http://rrr1.cccc");
requests.add(request);
try {
controller.updateRepositories(requests);
}
catch ( Exception e) {
String exceptionMsg=e.getMessage();
assertTrue(exceptionMsg.contains("Could not access base url"));
}
requests.clear();
request=new RepositoryRequest(STACK_NAME,STACK_VERSION,OS_TYPE,REPO_ID);
request.setBaseUrl(repo.getDefaultBaseUrl());
requests.add(request);
try {
controller.updateRepositories(requests);
Assert.assertEquals(repo.getBaseUrl(),repo.getDefaultBaseUrl());
}
catch ( Exception e) {
String exceptionMsg=e.getMessage();
assertTrue(exceptionMsg.contains("Could not access base url"));
LOG.error("Can not complete test. " + exceptionMsg);
}
String baseUrl=repo.getDefaultBaseUrl();
if (!baseUrl.endsWith("/")) {
baseUrl+="/";
}
backingProperties.setProperty(Configuration.REPO_SUFFIX_KEY_UBUNTU,"/repodata/repomd.xml");
Assert.assertTrue(baseUrl.endsWith("/") && configuration.getRepoValidationSuffixes("ubuntu12")[0].startsWith("/"));
request.setBaseUrl(baseUrl);
try {
controller.updateRepositories(requests);
Assert.assertEquals(baseUrl,repo.getBaseUrl());
}
catch ( Exception e) {
String exceptionMsg=e.getMessage();
assertTrue(exceptionMsg.contains("Could not access base url"));
LOG.error("Can not complete test. " + exceptionMsg);
}
backingProperties.setProperty(Configuration.REPO_SUFFIX_KEY_DEFAULT,"repodata/repomd.xml");
Assert.assertTrue(baseUrl.endsWith("/") && !configuration.getRepoValidationSuffixes("redhat6")[0].startsWith("/"));
request.setBaseUrl(baseUrl);
try {
controller.updateRepositories(requests);
Assert.assertEquals(baseUrl,repo.getBaseUrl());
}
catch ( Exception e) {
String exceptionMsg=e.getMessage();
assertTrue(exceptionMsg.contains("Could not access base url"));
LOG.error("Can not complete test. " + exceptionMsg);
}
baseUrl=baseUrl.substring(0,baseUrl.length() - 1);
Assert.assertTrue(!baseUrl.endsWith("/") && !configuration.getRepoValidationSuffixes("redhat6")[0].startsWith("/"));
request.setBaseUrl(baseUrl);
try {
controller.updateRepositories(requests);
Assert.assertEquals(baseUrl,repo.getBaseUrl());
}
catch ( Exception e) {
String exceptionMsg=e.getMessage();
assertTrue(exceptionMsg.contains("Could not access base url"));
LOG.error("Can not complete test. " + exceptionMsg);
}
backingProperties.setProperty(Configuration.REPO_SUFFIX_KEY_DEFAULT,"/repodata/repomd.xml");
Assert.assertTrue(!baseUrl.endsWith("/") && configuration.getRepoValidationSuffixes("suse11")[0].startsWith("/"));
request.setBaseUrl(baseUrl);
try {
controller.updateRepositories(requests);
Assert.assertEquals(baseUrl,repo.getBaseUrl());
}
catch ( Exception e) {
String exceptionMsg=e.getMessage();
assertTrue(exceptionMsg.contains("Could not access base url"));
LOG.error("Can not complete test. " + exceptionMsg);
}
backingProperties.setProperty(Configuration.REPO_SUFFIX_KEY_UBUNTU,"/foo/bar.xml,/repodata/repomd.xml");
Assert.assertTrue(configuration.getRepoValidationSuffixes("ubuntu12").length > 1);
request.setBaseUrl(baseUrl);
try {
controller.updateRepositories(requests);
Assert.assertEquals(baseUrl,repo.getBaseUrl());
}
catch ( Exception e) {
String exceptionMsg=e.getMessage();
assertTrue(exceptionMsg.contains("Could not access base url"));
LOG.error("Can not complete test. " + exceptionMsg);
}
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier requestProperties=new HashMap();
requestProperties.put("context","Called from a test");
Cluster cluster=clusters.getCluster(clusterName);
for ( Service service : cluster.getServices().values()) {
Assert.assertEquals(State.STARTED,service.getDesiredState());
}
Service service2=cluster.getService(serviceName2);
service2.setMaintenanceState(MaintenanceState.ON);
Set srs=new HashSet();
srs.add(new ServiceRequest(clusterName,serviceName1,State.INSTALLED.name()));
srs.add(new ServiceRequest(clusterName,serviceName2,State.INSTALLED.name()));
RequestStatusResponse rsr=ServiceResourceProviderTest.updateServices(controller,srs,requestProperties,false,false,maintenanceStateHelper);
for ( ShortTaskStatus sts : rsr.getTasks()) {
String role=sts.getRole();
Assert.assertFalse(role.equals(componentName2_1));
Assert.assertFalse(role.equals(componentName2_2));
}
for ( Service service : cluster.getServices().values()) {
if (service.getName().equals(serviceName2)) {
Assert.assertEquals(State.STARTED,service.getDesiredState());
}
else {
Assert.assertEquals(State.INSTALLED,service.getDesiredState());
}
}
service2.setMaintenanceState(MaintenanceState.OFF);
ServiceResourceProviderTest.updateServices(controller,srs,requestProperties,false,false,maintenanceStateHelper);
for ( Service service : cluster.getServices().values()) {
Assert.assertEquals(State.INSTALLED,service.getDesiredState());
}
startService(clusterName,serviceName1,false,false,maintenanceStateHelper);
startService(clusterName,serviceName2,false,false,maintenanceStateHelper);
Host h1=clusters.getHost(host1);
h1.setMaintenanceState(cluster.getClusterId(),MaintenanceState.ON);
srs=new HashSet();
srs.add(new ServiceRequest(clusterName,serviceName1,State.INSTALLED.name()));
srs.add(new ServiceRequest(clusterName,serviceName2,State.INSTALLED.name()));
rsr=ServiceResourceProviderTest.updateServices(controller,srs,requestProperties,false,false,maintenanceStateHelper);
for ( ShortTaskStatus sts : rsr.getTasks()) {
Assert.assertFalse(sts.getHostName().equals(host1));
}
h1.setMaintenanceState(cluster.getClusterId(),MaintenanceState.OFF);
startService(clusterName,serviceName2,false,false,maintenanceStateHelper);
service2.setMaintenanceState(MaintenanceState.ON);
ServiceRequest sr=new ServiceRequest(clusterName,serviceName2,State.INSTALLED.name());
rsr=ServiceResourceProviderTest.updateServices(controller,Collections.singleton(sr),requestProperties,false,false,maintenanceStateHelper);
Assert.assertTrue("Service start request defaults to Cluster operation level," + "command does not create tasks",rsr == null || rsr.getTasks().size() == 0);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier configs=new HashMap();
configs.put("a","b");
Map configs2=new HashMap();
configs2.put("c","d");
Map configs3=new HashMap();
ConfigurationRequest cr1, cr2, cr3, cr4;
cr1=new ConfigurationRequest(clusterName,"core-site","version1",configs,null);
cr2=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
cr4=new ConfigurationRequest(clusterName,"kerberos-env","version1",configs3,null);
ConfigFactory cf=injector.getInstance(ConfigFactory.class);
Config config1=cf.createNew(cluster,"kerberos-env",new HashMap(),new HashMap>());
config1.setTag("version1");
cluster.addConfig(config1);
ClusterRequest crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr2));
controller.updateClusters(Collections.singleton(crReq),null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr4));
controller.updateClusters(Collections.singleton(crReq),null);
long requestId1=installService(clusterName,serviceName1,true,false);
List stages=actionDB.getAllStages(requestId1);
Assert.assertEquals(3,stages.get(0).getOrderedHostRoleCommands().get(0).getExecutionCommandWrapper().getExecutionCommand().getConfigurationTags().size());
installService(clusterName,serviceName2,false,false);
startService(clusterName,serviceName1,true,false);
startService(clusterName,serviceName2,true,false);
cr3=new ConfigurationRequest(clusterName,"core-site","version122",configs2,null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr3));
controller.updateClusters(Collections.singleton(crReq),null);
stopService(clusterName,serviceName1,false,false);
stopService(clusterName,serviceName2,false,false);
long requestId2=startService(clusterName,serviceName1,true,true);
long requestId3=startService(clusterName,serviceName2,true,true);
stages=new ArrayList<>();
stages.addAll(actionDB.getAllStages(requestId2));
stages.addAll(actionDB.getAllStages(requestId3));
HostRoleCommand hdfsCmdHost3=null;
HostRoleCommand hdfsCmdHost2=null;
HostRoleCommand mapRedCmdHost2=null;
HostRoleCommand mapRedCmdHost3=null;
for ( Stage stage : stages) {
List hrcs=stage.getOrderedHostRoleCommands();
for ( HostRoleCommand hrc : hrcs) {
LOG.debug("role: " + hrc.getRole());
if (hrc.getRole().toString().equals("HDFS_CLIENT")) {
if (hrc.getHostName().equals(host3)) {
hdfsCmdHost3=hrc;
}
else if (hrc.getHostName().equals(host2)) {
hdfsCmdHost2=hrc;
}
}
if (hrc.getRole().toString().equals("MAPREDUCE_CLIENT")) {
if (hrc.getHostName().equals(host2)) {
mapRedCmdHost2=hrc;
}
else if (hrc.getHostName().equals(host3)) {
mapRedCmdHost3=hrc;
}
}
}
}
Assert.assertNotNull(hdfsCmdHost3);
Assert.assertNotNull(hdfsCmdHost2);
ExecutionCommand execCmd=hdfsCmdHost3.getExecutionCommandWrapper().getExecutionCommand();
Assert.assertEquals(3,execCmd.getConfigurationTags().size());
Assert.assertEquals("version122",execCmd.getConfigurationTags().get("core-site").get("tag"));
Assert.assertEquals("d",execCmd.getConfigurations().get("core-site").get("c"));
Assert.assertNotNull(mapRedCmdHost2);
Assert.assertNotNull(mapRedCmdHost3);
stopService(clusterName,serviceName1,false,false);
stopService(clusterName,serviceName2,false,false);
clusters.getHost(host2).setState(HostState.HEARTBEAT_LOST);
requestId3=startService(clusterName,serviceName2,true,true);
stages=actionDB.getAllStages(requestId3);
HostRoleCommand clientWithHostDown=null;
for ( Stage stage : stages) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().toString().equals("MAPREDUCE_CLIENT") && hrc.getHostName().equals(host2)) {
clientWithHostDown=hrc;
}
}
}
Assert.assertNull(clientWithHostDown);
Assert.assertEquals(State.STARTED,clusters.getCluster(clusterName).getService("MAPREDUCE").getServiceComponent("TASKTRACKER").getServiceComponentHost(host1).getState());
Assert.assertEquals(State.STARTED,clusters.getCluster(clusterName).getService("HDFS").getServiceComponent("NAMENODE").getServiceComponentHost(host1).getState());
Assert.assertEquals(State.STARTED,clusters.getCluster(clusterName).getService("HDFS").getServiceComponent("DATANODE").getServiceComponentHost(host1).getState());
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier response=ServiceResourceProviderTest.getServices(controller,Collections.singleton(r));
Assert.assertEquals(2,response.size());
for ( ServiceResponse svc : response) {
Assert.assertTrue(svc.getServiceName().equals(serviceName) || svc.getServiceName().equals(serviceName2));
Assert.assertEquals("HDP-0.1",svc.getDesiredStackVersion());
Assert.assertEquals(State.INIT.toString(),svc.getDesiredState());
}
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (){
{
add(host1);
add(host2);
}
}
,"centos5");
String serviceName="HDFS";
createService(clusterName,serviceName,null);
String componentName1="NAMENODE";
String componentName2="DATANODE";
String componentName3="HDFS_CLIENT";
createServiceComponent(clusterName,serviceName,componentName1,State.INIT);
createServiceComponent(clusterName,serviceName,componentName2,State.INIT);
createServiceComponent(clusterName,serviceName,componentName3,State.INIT);
createServiceComponentHost(clusterName,serviceName,componentName1,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
installService(clusterName,serviceName,false,false);
startService(clusterName,serviceName,false,false);
Service s1=clusters.getCluster(clusterName).getService(serviceName);
s1.getServiceComponent(componentName2).getServiceComponentHost(host1).setComponentAdminState(HostComponentAdminState.DECOMMISSIONED);
s1.getServiceComponent(componentName2).getServiceComponentHost(host2).setComponentAdminState(HostComponentAdminState.INSERVICE);
ServiceComponentHostRequest r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
Set resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(5,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
r.setAdminState("DECOMMISSIONED");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
r.setAdminState("INSERVICE");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
r.setAdminState("INSTALLED");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(0,resps.size());
r=new ServiceComponentHostRequest(clusterName,"HDFS","DATANODE",host2,null);
r.setAdminState("DECOMMISSIONED");
try {
updateHostComponents(Collections.singleton(r),new HashMap(),false);
Assert.fail("Must throw exception when decommission attribute is updated.");
}
catch ( IllegalArgumentException ex) {
Assert.assertTrue(ex.getMessage().contains("Property adminState cannot be modified through update"));
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resps=ComponentResourceProviderTest.getComponents(controller,Collections.singleton(r));
Assert.assertEquals(1,resps.size());
ServiceComponentResponse resp=resps.iterator().next();
Assert.assertEquals(c1.getClusterName(),resp.getClusterName());
Assert.assertEquals(sc1.getName(),resp.getComponentName());
Assert.assertEquals(s1.getName(),resp.getServiceName());
Assert.assertEquals("HDP-0.1",resp.getDesiredStackVersion());
Assert.assertEquals(sc1.getDesiredState().toString(),resp.getDesiredState());
Assert.assertEquals(c1.getClusterId(),resp.getClusterId().longValue());
}
APIUtilityVerifier BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1, cr2;
cr1=new ConfigurationRequest(clusterName,"core-site","version1",configs,null);
cr2=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
ClusterRequest crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr2));
controller.updateClusters(Collections.singleton(crReq),null);
installService(clusterName,serviceName,false,false);
long requestId=startService(clusterName,serviceName,true,false);
List stages=actionDB.getAllStages(requestId);
boolean serviceCheckFound=false;
for ( Stage stage : stages) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.HDFS_SERVICE_CHECK)) {
serviceCheckFound=true;
Assert.assertEquals(2,hrc.getExecutionCommandWrapper().getExecutionCommand().getConfigurationTags().size());
}
}
}
Type type=new TypeToken>(){
}
.getType();
for ( Stage stage : actionDB.getAllStages(requestId)) {
Map hostParamsStage=StageUtils.getGson().fromJson(stage.getHostParamsStage(),type);
Assert.assertNotNull(hostParamsStage.get("jdk_location"));
}
Assert.assertEquals(true,serviceCheckFound);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1, cr2;
cr1=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
ClusterRequest crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
startService(clusterName,serviceName,false,false);
configs=new HashMap();
configs.put("a","c");
final Config config=new ConfigImpl("hdfs-site");
config.setProperties(configs);
config.setTag("version122");
Long groupId=createConfigGroup(clusters.getCluster(clusterName),"g1","t1",new ArrayList(){
{
add("h1");
add("h2");
}
}
,new ArrayList(){
{
add(config);
}
}
);
Assert.assertNotNull(groupId);
cluster=clusters.getCluster(clusterName);
Service s=cluster.getService(serviceName);
Assert.assertEquals(State.STARTED,s.getDesiredState());
Map params=new HashMap(){
{
put("test","test");
put("excluded_hosts"," h1 ");
}
}
;
RequestResourceFilter resourceFilter=new RequestResourceFilter("HDFS","NAMENODE",null);
ExecuteActionRequest request=new ExecuteActionRequest(clusterName,"DECOMMISSION",params,false);
request.getResourceFilters().add(resourceFilter);
Map requestProperties=new HashMap();
requestProperties.put(REQUEST_CONTEXT_PROPERTY,"Called from a test");
RequestStatusResponse response=controller.createAction(request,requestProperties);
List storedTasks=actionDB.getRequestTasks(response.getRequestId());
ExecutionCommand execCmd=storedTasks.get(0).getExecutionCommandWrapper().getExecutionCommand();
Assert.assertNotNull(storedTasks);
Assert.assertNotNull(execCmd.getConfigurationTags().get("hdfs-site"));
Assert.assertEquals(1,storedTasks.size());
HostRoleCommand command=storedTasks.get(0);
Assert.assertEquals(Role.NAMENODE,command.getRole());
Assert.assertEquals(RoleCommand.CUSTOM_COMMAND,command.getRoleCommand());
Assert.assertEquals("DECOMMISSION",execCmd.getHostLevelParams().get("custom_command"));
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
}
UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier set1=new HashSet();
try {
set1.clear();
ServiceRequest rInvalid=new ServiceRequest(null,null,null);
set1.add(rInvalid);
ServiceResourceProviderTest.createServices(controller,set1);
fail("Expected failure for invalid requests");
}
catch ( Exception e) {
}
try {
set1.clear();
ServiceRequest rInvalid=new ServiceRequest("foo",null,null);
set1.add(rInvalid);
ServiceResourceProviderTest.createServices(controller,set1);
fail("Expected failure for invalid requests");
}
catch ( Exception e) {
}
try {
set1.clear();
ServiceRequest rInvalid=new ServiceRequest("foo","bar",null);
set1.add(rInvalid);
ServiceResourceProviderTest.createServices(controller,set1);
fail("Expected failure for invalid cluster");
}
catch ( AmbariException e) {
Assert.assertTrue(checkExceptionType(e,ClusterNotFoundException.class));
}
clusters.addCluster("foo",new StackId("HDP-0.1"));
clusters.addCluster("bar",new StackId("HDP-0.1"));
try {
set1.clear();
ServiceRequest valid1=new ServiceRequest("foo","HDFS",null);
ServiceRequest valid2=new ServiceRequest("foo","HDFS",null);
set1.add(valid1);
set1.add(valid2);
ServiceResourceProviderTest.createServices(controller,set1);
fail("Expected failure for invalid requests");
}
catch ( Exception e) {
}
try {
set1.clear();
ServiceRequest valid1=new ServiceRequest("foo","bar",null);
set1.add(valid1);
ServiceResourceProviderTest.createServices(controller,set1);
fail("Expected failure for invalid service");
}
catch ( Exception e) {
}
try {
set1.clear();
ServiceRequest valid1=new ServiceRequest("foo","HDFS",null);
ServiceRequest valid2=new ServiceRequest("bar","HDFS",null);
set1.add(valid1);
set1.add(valid2);
ServiceResourceProviderTest.createServices(controller,set1);
fail("Expected failure for multiple clusters");
}
catch ( Exception e) {
}
Assert.assertNotNull(clusters.getCluster("foo"));
Assert.assertEquals(0,clusters.getCluster("foo").getServices().size());
set1.clear();
ServiceRequest valid=new ServiceRequest("foo","HDFS",null);
set1.add(valid);
ServiceResourceProviderTest.createServices(controller,set1);
try {
set1.clear();
ServiceRequest valid1=new ServiceRequest("foo","HDFS",null);
ServiceRequest valid2=new ServiceRequest("foo","HDFS",null);
set1.add(valid1);
set1.add(valid2);
ServiceResourceProviderTest.createServices(controller,set1);
fail("Expected failure for existing service");
}
catch ( Exception e) {
}
Assert.assertEquals(1,clusters.getCluster("foo").getServices().size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier responses=controller.getStackComponents(Collections.singleton(request));
Assert.assertEquals(STACK_COMPONENTS_CNT,responses.size());
StackServiceComponentRequest requestWithParams=new StackServiceComponentRequest(STACK_NAME,STACK_VERSION,SERVICE_NAME,COMPONENT_NAME);
Set responsesWithParams=controller.getStackComponents(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( StackServiceComponentResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getComponentName(),COMPONENT_NAME);
}
StackServiceComponentRequest invalidRequest=new StackServiceComponentRequest(STACK_NAME,STACK_VERSION,SERVICE_NAME,NON_EXT_VALUE);
try {
controller.getStackComponents(Collections.singleton(invalidRequest));
}
catch ( StackAccessException e) {
}
}
BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createServiceComponentHost(clusterName,null,componentName1,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName1).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName3).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName3).getServiceComponentHost(host2));
ServiceRequest r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
Set requests=new HashSet();
requests.add(r);
ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertEquals(State.INSTALLED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
r=new ServiceRequest(clusterName,serviceName,State.STARTED.toString());
requests.clear();
requests.add(r);
ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (!sch.getServiceComponentName().equals("HDFS_CLIENT")) {
sch.setState(State.STARTED);
}
}
}
Assert.assertEquals(State.STARTED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
clusters.getCluster(clusterName).getService(serviceName).setDesiredState(State.STOPPING);
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (!sch.getServiceComponentName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.STARTED,sch.getDesiredState());
sch.setState(State.STOPPING);
}
else if (sch.getServiceComponentName().equals("DATANODE")) {
ServiceComponentHostRequest r1=new ServiceComponentHostRequest(clusterName,serviceName,sch.getServiceComponentName(),sch.getHostName(),State.INSTALLED.name());
Set reqs1=new HashSet();
reqs1.add(r1);
updateHostComponents(reqs1,Collections.emptyMap(),true);
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
}
}
}
r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
requests.clear();
requests.add(r);
ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (!sch.getServiceComponentName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
}
}
}
}
InternalCallVerifier BooleanVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier commands=actionDB.getRequestTasks(requestId);
int commandCount=0;
for ( HostRoleCommand command : commands) {
if (command.getRoleCommand() == RoleCommand.SERVICE_CHECK && command.getRole() == Role.HDFS_SERVICE_CHECK) {
Assert.assertTrue(command.getHostName().equals("h2"));
commandCount++;
}
}
Assert.assertEquals("Expect only one service check.",1,commandCount);
stopService(clusterName,serviceName,false,false);
clusters.getHost("h3").setState(HostState.HEALTHY);
clusters.getHost("h2").setState(HostState.HEARTBEAT_LOST);
requestId=startService(clusterName,serviceName,true,false);
commands=actionDB.getRequestTasks(requestId);
commandCount=0;
for ( HostRoleCommand command : commands) {
if (command.getRoleCommand() == RoleCommand.SERVICE_CHECK && command.getRole() == Role.HDFS_SERVICE_CHECK) {
Assert.assertTrue(command.getHostName().equals("h3"));
commandCount++;
}
}
Assert.assertEquals("Expect only one service check.",1,commandCount);
RequestResourceFilter resourceFilter=new RequestResourceFilter("HDFS",null,null);
ExecuteActionRequest actionRequest=new ExecuteActionRequest("foo1",Role.HDFS_SERVICE_CHECK.name(),null,false);
actionRequest.getResourceFilters().add(resourceFilter);
Map requestProperties=new HashMap();
RequestStatusResponse response=controller.createAction(actionRequest,requestProperties);
commands=actionDB.getRequestTasks(response.getRequestId());
commandCount=0;
for ( HostRoleCommand command : commands) {
if (command.getRoleCommand() == RoleCommand.SERVICE_CHECK && command.getRole() == Role.HDFS_SERVICE_CHECK) {
Assert.assertTrue(command.getHostName().equals("h3"));
commandCount++;
}
}
Assert.assertEquals("Expect only one service check.",1,commandCount);
clusters.getHost("h3").setState(HostState.WAITING_FOR_HOST_STATUS_UPDATES);
clusters.getHost("h2").setState(HostState.INIT);
response=controller.createAction(actionRequest,requestProperties);
commands=actionDB.getRequestTasks(response.getRequestId());
commandCount=0;
for ( HostRoleCommand command : commands) {
if (command.getRoleCommand() == RoleCommand.SERVICE_CHECK && command.getRole() == Role.HDFS_SERVICE_CHECK) {
Assert.assertTrue(command.getHostName().equals("h3") || command.getHostName().equals("h2"));
commandCount++;
}
}
Assert.assertEquals("Expect only one service check.",1,commandCount);
Assert.assertEquals("",response.getRequestContext());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier configs=new HashMap();
Map properties=new HashMap();
Map> propertiesAttributes=new HashMap>();
Config c1=new ConfigImpl(cluster,"hdfs-site",properties,propertiesAttributes,injector);
c1.setTag("v1");
cluster.addConfig(c1);
c1.persist();
configs.put(c1.getType(),c1);
ServiceRequest r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
Set requests=new HashSet();
requests.add(r);
Map mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
RequestStatusResponse trackAction=ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
List taskStatuses=trackAction.getTasks();
Assert.assertFalse(taskStatuses.isEmpty());
for ( ShortTaskStatus task : taskStatuses) {
Assert.assertEquals("Task output logs don't match",Configuration.PREFIX_DIR + "/output-" + task.getTaskId()+ ".txt",task.getOutputLog());
Assert.assertEquals("Task error logs don't match",Configuration.PREFIX_DIR + "/errors-" + task.getTaskId()+ ".txt",task.getErrorLog());
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier (){
{
add(host1);
add(host2);
}
}
,"centos5");
String serviceName="HDFS";
createService(clusterName,serviceName,null);
String componentName1="NAMENODE";
String componentName2="DATANODE";
String componentName3="HDFS_CLIENT";
createServiceComponent(clusterName,serviceName,componentName1,State.INIT);
createServiceComponent(clusterName,serviceName,componentName2,State.INIT);
createServiceComponent(clusterName,serviceName,componentName3,State.INIT);
createServiceComponentHost(clusterName,serviceName,componentName1,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
installService(clusterName,serviceName,false,false);
Map configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1;
cr1=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
ClusterRequest crReq=new ClusterRequest(clusterId,clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
startService(clusterName,serviceName,false,false);
HashMap> actualConfig=new HashMap>(){
{
put("hdfs-site",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
;
HashMap> actualConfigOld=new HashMap>(){
{
put("hdfs-site",new HashMap(){
{
put("tag","version0");
}
}
);
}
}
;
Service s1=clusters.getCluster(clusterName).getService(serviceName);
s1.getServiceComponent(componentName1).getServiceComponentHost(host1).updateActualConfigs(actualConfig);
s1.getServiceComponent(componentName2).getServiceComponentHost(host1).updateActualConfigs(actualConfig);
s1.getServiceComponent(componentName3).getServiceComponentHost(host1).updateActualConfigs(actualConfigOld);
s1.getServiceComponent(componentName2).getServiceComponentHost(host2).updateActualConfigs(actualConfigOld);
s1.getServiceComponent(componentName3).getServiceComponentHost(host2).updateActualConfigs(actualConfig);
ServiceComponentHostRequest r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
Set resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(5,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
r.setStaleConfig("true");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,null,null);
r.setStaleConfig("false");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(3,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,host1,null);
r.setStaleConfig("false");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2,resps.size());
r=new ServiceComponentHostRequest(clusterName,null,null,host2,null);
r.setStaleConfig("true");
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
}
InternalCallVerifier EqualityVerifier set1=new HashSet();
set1.add(r1);
set1.add(r2);
set1.add(r3);
HostResourceProviderTest.createHosts(controller,set1);
Assert.assertEquals(1,clusters.getClustersForHost("h1").size());
Assert.assertEquals(1,clusters.getClustersForHost("h2").size());
Assert.assertEquals(0,clusters.getClustersForHost("h3").size());
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
add("h1");
}
}
,"centos5");
Cluster cluster=clusters.getCluster("c1");
cluster.setDesiredStackVersion(new StackId("HDP-2.0.7"));
cluster.setCurrentStackVersion(new StackId("HDP-2.0.7"));
ConfigFactory cf=injector.getInstance(ConfigFactory.class);
Config config1=cf.createNew(cluster,"global",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config1.setTag("version1");
Config config2=cf.createNew(cluster,"core-site",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config2.setTag("version1");
cluster.addConfig(config1);
cluster.addConfig(config2);
Service hdfs=cluster.addService("HDFS");
hdfs.persist();
hdfs.addServiceComponent(Role.HDFS_CLIENT.name()).persist();
hdfs.addServiceComponent(Role.NAMENODE.name()).persist();
hdfs.addServiceComponent(Role.DATANODE.name()).persist();
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.NAMENODE.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost("h1").persist();
installService("c1","HDFS",false,false);
startService("c1","HDFS",false,false);
Cluster c=clusters.getCluster("c1");
Service s=c.getService("HDFS");
Assert.assertEquals(State.STARTED,s.getDesiredState());
for ( ServiceComponent sc : s.getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (sc.isClientComponent()) {
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
}
else {
Assert.assertEquals(State.STARTED,sch.getDesiredState());
}
}
}
Map params=new HashMap(){
{
put("test","test");
}
}
;
RequestResourceFilter resourceFilter=new RequestResourceFilter("HDFS","HDFS_CLIENT",new ArrayList(){
{
add("h1");
}
}
);
ExecuteActionRequest actionRequest=new ExecuteActionRequest("c1","RESTART",params,false);
actionRequest.getResourceFilters().add(resourceFilter);
Map requestProperties=new HashMap();
requestProperties.put(REQUEST_CONTEXT_PROPERTY,"Called from a test");
requestProperties.put("hdfs_client","abc");
RequestStatusResponse response=controller.createAction(actionRequest,requestProperties);
List stages=actionDB.getAllStages(response.getRequestId());
Assert.assertNotNull(stages);
HostRoleCommand hrc=null;
Type type=new TypeToken>(){
}
.getType();
for ( Stage stage : stages) {
for ( HostRoleCommand cmd : stage.getOrderedHostRoleCommands()) {
if (cmd.getRole().equals(Role.HDFS_CLIENT)) {
hrc=cmd;
}
Map hostParamStage=StageUtils.getGson().fromJson(stage.getHostParamsStage(),type);
Assert.assertTrue(hostParamStage.containsKey(ExecutionCommand.KeyNames.DB_DRIVER_FILENAME));
Assert.assertTrue(hostParamStage.containsKey(ExecutionCommand.KeyNames.MYSQL_JDBC_URL));
Assert.assertTrue(hostParamStage.containsKey(ExecutionCommand.KeyNames.ORACLE_JDBC_URL));
}
}
Assert.assertNotNull(hrc);
Assert.assertEquals("RESTART HDFS/HDFS_CLIENT",hrc.getCommandDetail());
Map roleParams=hrc.getExecutionCommandWrapper().getExecutionCommand().getRoleParams();
Assert.assertNotNull(roleParams);
Assert.assertEquals("CLIENT",roleParams.get(ExecutionCommand.KeyNames.COMPONENT_CATEGORY));
Assert.assertTrue(hrc.getExecutionCommandWrapper().getExecutionCommand().getCommandParams().containsKey("hdfs_client"));
Assert.assertEquals("abc",hrc.getExecutionCommandWrapper().getExecutionCommand().getCommandParams().get("hdfs_client"));
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier IgnoredMethod HybridVerifier set1=new HashSet();
ServiceComponentHostRequest r1=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host1,State.INIT.toString());
ServiceComponentHostRequest r2=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host2,State.INIT.toString());
ServiceComponentHostRequest r3=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host1,State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
controller.createHostComponents(set1);
Cluster c1=clusters.getCluster(clusterName);
Service s1=c1.getService(serviceName1);
ServiceComponent sc1=s1.getServiceComponent(componentName1);
ServiceComponent sc2=s1.getServiceComponent(componentName2);
ServiceComponentHost sch1=sc1.getServiceComponentHost(host1);
ServiceComponentHost sch2=sc1.getServiceComponentHost(host2);
ServiceComponentHost sch3=sc2.getServiceComponentHost(host1);
s1.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.INSTALLED);
sc2.setDesiredState(State.INSTALLED);
ServiceComponentHostRequest req1;
ServiceComponentHostRequest req2;
ServiceComponentHostRequest req3;
Set reqs=new HashSet();
StackId newStack=new StackId("HDP-0.2");
StackId oldStack=new StackId("HDP-0.1");
c1.setCurrentStackVersion(newStack);
c1.setDesiredStackVersion(newStack);
sch1.setState(State.INSTALLED);
sch2.setState(State.UPGRADING);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INSTALLED);
sch1.setStackVersion(oldStack);
sch2.setStackVersion(oldStack);
sch1.setDesiredStackVersion(newStack);
sch2.setDesiredStackVersion(oldStack);
reqs.clear();
req1=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host1,State.INSTALLED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
req2=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host2,State.INSTALLED.toString());
req2.setDesiredStackId("HDP-0.2");
reqs.add(req2);
Map mapRequestProps=new HashMap();
mapRequestProps.put("context","testServiceComponentHostUpdateStackId");
RequestStatusResponse resp=updateHostComponents(reqs,mapRequestProps,true);
List stages=actionDB.getAllStages(resp.getRequestId());
Assert.assertEquals(1,stages.size());
Assert.assertEquals(2,stages.get(0).getOrderedHostRoleCommands().size());
Assert.assertEquals("testServiceComponentHostUpdateStackId",stages.get(0).getRequestContext());
Assert.assertEquals(State.UPGRADING,sch1.getState());
Assert.assertEquals(State.UPGRADING,sch2.getState());
sch1.refresh();
Assert.assertTrue(sch1.getDesiredStackVersion().compareTo(newStack) == 0);
sch2.refresh();
Assert.assertTrue(sch2.getDesiredStackVersion().compareTo(newStack) == 0);
for ( HostRoleCommand command : stages.get(0).getOrderedHostRoleCommands()) {
ExecutionCommand execCommand=command.getExecutionCommandWrapper().getExecutionCommand();
Assert.assertTrue(execCommand.getCommandParams().containsKey("source_stack_version"));
Assert.assertTrue(execCommand.getCommandParams().containsKey("target_stack_version"));
Assert.assertEquals(RoleCommand.UPGRADE,execCommand.getRoleCommand());
}
sch1.setState(State.INSTALLED);
sch1.setDesiredState(State.INSTALLED);
sch2.setState(State.UPGRADING);
sch2.setDesiredState(State.INSTALLED);
sch3.setState(State.UPGRADING);
sch3.setDesiredState(State.INSTALLED);
sch3.setStackVersion(oldStack);
sch3.setDesiredStackVersion(newStack);
reqs.clear();
req1=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host1,State.INSTALLED.toString());
req1.setDesiredStackId("HDP-0.2");
reqs.add(req1);
req2=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host2,State.INSTALLED.toString());
req2.setDesiredStackId("HDP-0.2");
reqs.add(req2);
req3=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host1,State.INSTALLED.toString());
req3.setDesiredStackId("HDP-0.2");
reqs.add(req3);
resp=updateHostComponents(reqs,Collections.emptyMap(),true);
stages=actionDB.getAllStages(resp.getRequestId());
Assert.assertEquals(2,stages.size());
Assert.assertEquals(2,stages.get(0).getOrderedHostRoleCommands().size());
Assert.assertEquals("",stages.get(0).getRequestContext());
Assert.assertEquals(State.UPGRADING,sch1.getState());
Assert.assertEquals(State.UPGRADING,sch2.getState());
Assert.assertEquals(State.UPGRADING,sch3.getState());
sch1.refresh();
Assert.assertTrue(sch1.getDesiredStackVersion().compareTo(newStack) == 0);
sch2.refresh();
Assert.assertTrue(sch2.getDesiredStackVersion().compareTo(newStack) == 0);
sch3.refresh();
Assert.assertTrue(sch3.getDesiredStackVersion().compareTo(newStack) == 0);
for ( Stage stage : stages) {
for ( HostRoleCommand command : stage.getOrderedHostRoleCommands()) {
ExecutionCommand execCommand=command.getExecutionCommandWrapper().getExecutionCommand();
Assert.assertTrue(execCommand.getCommandParams().containsKey("source_stack_version"));
Assert.assertTrue(execCommand.getCommandParams().containsKey("target_stack_version"));
Assert.assertEquals("{\"stackName\":\"HDP\",\"stackVersion\":\"0.2\"}",execCommand.getCommandParams().get("target_stack_version"));
Assert.assertEquals(RoleCommand.UPGRADE,execCommand.getRoleCommand());
}
}
}
UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier ());
Config config=cluster.getDesiredConfigByType("typeA");
Assert.assertNull(config);
cr.setDesiredConfig(Collections.singletonList(new ConfigurationRequest(clusterName,"typeA","v1",new HashMap(),new HashMap>())));
controller.updateClusters(Collections.singleton(cr),new HashMap());
config=cluster.getDesiredConfigByType("typeA");
Assert.assertNotNull(config);
cr.setDesiredConfig(Collections.singletonList(new ConfigurationRequest(clusterName,"typeA","v2",new HashMap(),new HashMap>())));
controller.updateClusters(Collections.singleton(cr),new HashMap());
config=cluster.getDesiredConfigByType("typeA");
Assert.assertNotNull(config);
Assert.assertEquals(Integer.valueOf(0),Integer.valueOf(config.getProperties().size()));
Map map=new HashMap();
map.clear();
map.put("c","d");
Map> attributesMap=new HashMap>();
attributesMap.put("final",new HashMap());
attributesMap.get("final").put("c","true");
cr.setDesiredConfig(Collections.singletonList(new ConfigurationRequest(clusterName,"typeA","v3",map,attributesMap)));
controller.updateClusters(Collections.singleton(cr),new HashMap());
config=cluster.getDesiredConfigByType("typeA");
Assert.assertNotNull(config);
Assert.assertTrue(config.getProperties().containsKey("c"));
cr.setDesiredConfig(Collections.singletonList(new ConfigurationRequest(clusterName,"typeA","v2",new HashMap(),new HashMap>())));
controller.updateClusters(Collections.singleton(cr),new HashMap());
config=cluster.getDesiredConfigByType("typeA");
Assert.assertEquals("v2",config.getTag());
Assert.assertNotNull(config);
Assert.assertEquals(Integer.valueOf(0),Integer.valueOf(config.getProperties().size()));
cr.setDesiredConfig(Collections.singletonList(new ConfigurationRequest(clusterName,"typeA","v2",new HashMap(){
{
put("a","b");
}
}
,new HashMap>(){
{
put("final",new HashMap(){
{
put("a","true");
}
}
);
}
}
)));
try {
controller.updateClusters(Collections.singleton(cr),new HashMap());
Assert.fail("Expect failure when creating a config that exists");
}
catch ( AmbariException e) {
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier IgnoredMethod HybridVerifier mapRequestProps=new HashMap();
Injector injector=Guice.createInjector(new AbstractModule(){
@Override protected void configure(){
Properties properties=new Properties();
properties.setProperty(Configuration.SERVER_PERSISTENCE_TYPE_KEY,"in-memory");
properties.setProperty(Configuration.METADATA_DIR_PATH,"src/test/resources/stacks");
properties.setProperty(Configuration.SERVER_VERSION_FILE,"src/test/resources/version");
properties.setProperty(Configuration.OS_VERSION_KEY,"centos5");
properties.setProperty(Configuration.SHARED_RESOURCES_DIR_KEY,"src/test/resources/");
try {
install(new ControllerModule(properties));
bind(AmbariEventPublisher.class).toInstance(EasyMock.createMock(AmbariEventPublisher.class));
}
catch ( Exception e) {
throw new RuntimeException(e);
}
}
}
);
injector.getInstance(GuiceJpaInitializer.class);
try {
AmbariManagementController amc=injector.getInstance(AmbariManagementController.class);
Clusters clusters=injector.getInstance(Clusters.class);
Gson gson=new Gson();
clusters.addHost("host1");
clusters.addHost("host2");
clusters.addHost("host3");
Host host=clusters.getHost("host1");
setOsFamily(host,"redhat","5.9");
host.persist();
host=clusters.getHost("host2");
setOsFamily(host,"redhat","5.9");
host.persist();
host=clusters.getHost("host3");
setOsFamily(host,"redhat","5.9");
host.persist();
ClusterRequest clusterRequest=new ClusterRequest(null,"c1","HDP-1.2.0",null);
amc.createCluster(clusterRequest);
Set serviceRequests=new HashSet();
serviceRequests.add(new ServiceRequest("c1","HDFS",null));
serviceRequests.add(new ServiceRequest("c1","HIVE",null));
ServiceResourceProviderTest.createServices(amc,serviceRequests);
Type confType=new TypeToken>(){
}
.getType();
ConfigurationRequest configurationRequest=new ConfigurationRequest("c1","core-site","version1",gson.>fromJson("{ \"fs.default.name\" : \"localhost:8020\"}",confType),null);
amc.createConfiguration(configurationRequest);
configurationRequest=new ConfigurationRequest("c1","hdfs-site","version1",gson.>fromJson("{ \"dfs.datanode.data.dir.perm\" : \"750\"}",confType),null);
amc.createConfiguration(configurationRequest);
configurationRequest=new ConfigurationRequest("c1","global","version1",gson.>fromJson("{ \"hive.server2.enable.doAs\" : \"true\"}",confType),null);
amc.createConfiguration(configurationRequest);
Assert.assertTrue(clusters.getCluster("c1").getDesiredConfigs().containsKey("hive-site"));
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1","HDFS",null));
ServiceResourceProviderTest.updateServices(amc,serviceRequests,mapRequestProps,true,false);
Set serviceComponentRequests=new HashSet();
serviceComponentRequests.add(new ServiceComponentRequest("c1","HDFS","NAMENODE",null));
serviceComponentRequests.add(new ServiceComponentRequest("c1","HDFS","SECONDARY_NAMENODE",null));
serviceComponentRequests.add(new ServiceComponentRequest("c1","HDFS","DATANODE",null));
serviceComponentRequests.add(new ServiceComponentRequest("c1","HDFS","HDFS_CLIENT",null));
ComponentResourceProviderTest.createComponents(amc,serviceComponentRequests);
Set hostRequests=new HashSet();
hostRequests.add(new HostRequest("host1","c1",null));
hostRequests.add(new HostRequest("host2","c1",null));
hostRequests.add(new HostRequest("host3","c1",null));
HostResourceProviderTest.createHosts(amc,hostRequests);
Set componentHostRequests=new HashSet();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"DATANODE","host1",null));
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host1",null));
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"SECONDARY_NAMENODE","host1",null));
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"DATANODE","host2",null));
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"DATANODE","host3",null));
amc.createHostComponents(componentHostRequests);
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1","HDFS","INSTALLED"));
ServiceResourceProviderTest.updateServices(amc,serviceRequests,mapRequestProps,true,false);
Cluster cluster=clusters.getCluster("c1");
Map namenodes=cluster.getService("HDFS").getServiceComponent("NAMENODE").getServiceComponentHosts();
org.junit.Assert.assertEquals(1,namenodes.size());
ServiceComponentHost componentHost=namenodes.get("host1");
Map hostComponents=cluster.getService("HDFS").getServiceComponent("DATANODE").getServiceComponentHosts();
for ( Map.Entry entry : hostComponents.entrySet()) {
ServiceComponentHost cHost=entry.getValue();
cHost.handleEvent(new ServiceComponentHostInstallEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis(),"HDP-1.2.0"));
cHost.handleEvent(new ServiceComponentHostOpSucceededEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis()));
}
hostComponents=cluster.getService("HDFS").getServiceComponent("NAMENODE").getServiceComponentHosts();
for ( Map.Entry entry : hostComponents.entrySet()) {
ServiceComponentHost cHost=entry.getValue();
cHost.handleEvent(new ServiceComponentHostInstallEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis(),"HDP-1.2.0"));
cHost.handleEvent(new ServiceComponentHostOpSucceededEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis()));
}
hostComponents=cluster.getService("HDFS").getServiceComponent("SECONDARY_NAMENODE").getServiceComponentHosts();
for ( Map.Entry entry : hostComponents.entrySet()) {
ServiceComponentHost cHost=entry.getValue();
cHost.handleEvent(new ServiceComponentHostInstallEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis(),"HDP-1.2.0"));
cHost.handleEvent(new ServiceComponentHostOpSucceededEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis()));
}
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host1","DISABLED"));
updateHostComponents(amc,componentHostRequests,mapRequestProps,true);
Assert.assertEquals(State.DISABLED,componentHost.getState());
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host1","INSTALLED"));
updateHostComponents(amc,componentHostRequests,mapRequestProps,true);
Assert.assertEquals(State.INSTALLED,componentHost.getState());
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host1","DISABLED"));
updateHostComponents(amc,componentHostRequests,mapRequestProps,true);
Assert.assertEquals(State.DISABLED,componentHost.getState());
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host2",null));
amc.createHostComponents(componentHostRequests);
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host2","INSTALLED"));
updateHostComponents(amc,componentHostRequests,mapRequestProps,true);
namenodes=cluster.getService("HDFS").getServiceComponent("NAMENODE").getServiceComponentHosts();
Assert.assertEquals(2,namenodes.size());
componentHost=namenodes.get("host2");
componentHost.handleEvent(new ServiceComponentHostInstallEvent(componentHost.getServiceComponentName(),componentHost.getHostName(),System.currentTimeMillis(),"HDP-1.2.0"));
componentHost.handleEvent(new ServiceComponentHostOpSucceededEvent(componentHost.getServiceComponentName(),componentHost.getHostName(),System.currentTimeMillis()));
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1","HDFS","STARTED"));
RequestStatusResponse response=ServiceResourceProviderTest.updateServices(amc,serviceRequests,mapRequestProps,true,false);
for ( ShortTaskStatus shortTaskStatus : response.getTasks()) {
assertFalse("host1".equals(shortTaskStatus.getHostName()) && "NAMENODE".equals(shortTaskStatus.getRole()));
}
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host1",null));
amc.deleteHostComponents(componentHostRequests);
namenodes=cluster.getService("HDFS").getServiceComponent("NAMENODE").getServiceComponentHosts();
org.junit.Assert.assertEquals(1,namenodes.size());
testRunSmokeTestFlag(mapRequestProps,amc,serviceRequests);
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host1",null));
amc.createHostComponents(componentHostRequests);
namenodes=cluster.getService("HDFS").getServiceComponent("NAMENODE").getServiceComponentHosts();
assertEquals(2,namenodes.size());
componentHost=namenodes.get("host1");
componentHost.handleEvent(new ServiceComponentHostInstallEvent(componentHost.getServiceComponentName(),componentHost.getHostName(),System.currentTimeMillis(),"HDP-1.2.0"));
componentHost.handleEvent(new ServiceComponentHostOpSucceededEvent(componentHost.getServiceComponentName(),componentHost.getHostName(),System.currentTimeMillis()));
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host1","INSTALLED"));
updateHostComponents(amc,componentHostRequests,mapRequestProps,true);
assertEquals(State.INSTALLED,namenodes.get("host1").getState());
ServiceComponentHost sch=null;
for ( ServiceComponentHost tmp : cluster.getServiceComponentHosts("host2")) {
if (tmp.getServiceComponentName().equals("DATANODE")) {
tmp.setState(State.UNKNOWN);
sch=tmp;
}
}
assertNotNull(sch);
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"DATANODE","host2","DISABLED"));
updateHostComponents(amc,componentHostRequests,mapRequestProps,false);
org.junit.Assert.assertEquals(State.DISABLED,sch.getState());
componentHostRequests.clear();
mapRequestProps.put(RequestOperationLevel.OPERATION_CLUSTER_ID,"c1");
updateHostComponents(amc,componentHostRequests,mapRequestProps,false);
org.junit.Assert.assertEquals(State.DISABLED,sch.getState());
mapRequestProps.clear();
assertEquals(sch.getServiceComponentName(),"DATANODE");
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1","HDFS","INSTALLED"));
ServiceResourceProviderTest.updateServices(amc,serviceRequests,mapRequestProps,true,false);
assertEquals(State.DISABLED,sch.getState());
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1","HDFS","STARTED"));
ServiceResourceProviderTest.updateServices(amc,serviceRequests,mapRequestProps,true,false);
assertEquals(State.DISABLED,sch.getState());
componentHostRequests.clear();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"DATANODE","host2",null));
amc.deleteHostComponents(componentHostRequests);
sch=null;
for ( ServiceComponentHost tmp : cluster.getServiceComponentHosts("host2")) {
if (tmp.getServiceComponentName().equals("DATANODE")) {
sch=tmp;
}
}
org.junit.Assert.assertNull(sch);
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1","HDFS","INSTALLED"));
ServiceResourceProviderTest.updateServices(amc,serviceRequests,mapRequestProps,true,false);
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1",null,null));
org.junit.Assert.assertEquals(2,ServiceResourceProviderTest.getServices(amc,serviceRequests).size());
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1","HDFS",null));
serviceRequests.add(new ServiceRequest("c1","HIVE",null));
ServiceResourceProviderTest.deleteServices(amc,serviceRequests);
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1",null,null));
org.junit.Assert.assertEquals(0,ServiceResourceProviderTest.getServices(amc,serviceRequests).size());
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1","HDFS",null));
ServiceResourceProviderTest.createServices(amc,serviceRequests);
org.junit.Assert.assertEquals(1,ServiceResourceProviderTest.getServices(amc,serviceRequests).size());
configurationRequest=new ConfigurationRequest("c1","core-site","version2",gson.>fromJson("{ \"fs.default.name\" : \"localhost:8020\"}",confType),null);
amc.createConfiguration(configurationRequest);
configurationRequest=new ConfigurationRequest("c1","hdfs-site","version2",gson.>fromJson("{ \"dfs.datanode.data.dir.perm\" : \"750\"}",confType),null);
amc.createConfiguration(configurationRequest);
configurationRequest=new ConfigurationRequest("c1","global","version2",gson.>fromJson("{ \"hbase_hdfs_root_dir\" : \"/apps/hbase/\"}",confType),null);
amc.createConfiguration(configurationRequest);
serviceRequests.clear();
serviceRequests.add(new ServiceRequest("c1","HDFS",null));
ServiceResourceProviderTest.updateServices(amc,serviceRequests,mapRequestProps,true,false);
serviceComponentRequests=new HashSet();
serviceComponentRequests.add(new ServiceComponentRequest("c1","HDFS","NAMENODE",null));
serviceComponentRequests.add(new ServiceComponentRequest("c1","HDFS","SECONDARY_NAMENODE",null));
serviceComponentRequests.add(new ServiceComponentRequest("c1","HDFS","DATANODE",null));
serviceComponentRequests.add(new ServiceComponentRequest("c1","HDFS","HDFS_CLIENT",null));
ComponentResourceProviderTest.createComponents(amc,serviceComponentRequests);
componentHostRequests=new HashSet();
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"DATANODE","host1",null));
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"NAMENODE","host1",null));
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"SECONDARY_NAMENODE","host1",null));
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"DATANODE","host2",null));
componentHostRequests.add(new ServiceComponentHostRequest("c1",null,"DATANODE","host3",null));
amc.createHostComponents(componentHostRequests);
namenodes=cluster.getService("HDFS").getServiceComponent("NAMENODE").getServiceComponentHosts();
org.junit.Assert.assertEquals(1,namenodes.size());
Map datanodes=cluster.getService("HDFS").getServiceComponent("DATANODE").getServiceComponentHosts();
org.junit.Assert.assertEquals(3,datanodes.size());
Map namenodes2=cluster.getService("HDFS").getServiceComponent("SECONDARY_NAMENODE").getServiceComponentHosts();
org.junit.Assert.assertEquals(1,namenodes2.size());
}
finally {
injector.getInstance(PersistService.class).stop();
}
}
APIUtilityVerifier BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1, cr2;
cr1=new ConfigurationRequest(clusterName,"core-site","version1",configs,null);
cr2=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
ClusterRequest crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr2));
controller.updateClusters(Collections.singleton(crReq),null);
installService(clusterName,serviceName,false,false);
configs=new HashMap();
configs.put("a","c");
final Config config=new ConfigImpl("hdfs-site");
config.setProperties(configs);
config.setTag("version122");
Long groupId=createConfigGroup(clusters.getCluster(clusterName),"g1","t1",new ArrayList(){
{
add("h1");
add("h2");
}
}
,new ArrayList(){
{
add(config);
}
}
);
Assert.assertNotNull(groupId);
long requestId=startService(clusterName,serviceName,true,false);
HostRoleCommand smokeTestCmd=null;
List stages=actionDB.getAllStages(requestId);
for ( Stage stage : stages) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.HDFS_SERVICE_CHECK)) {
Assert.assertEquals(2,hrc.getExecutionCommandWrapper().getExecutionCommand().getConfigurationTags().size());
smokeTestCmd=hrc;
}
}
}
Assert.assertNotNull(smokeTestCmd);
Assert.assertEquals("c",smokeTestCmd.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().get("hdfs-site").get("a"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier mapRequestProps=Collections.emptyMap();
Injector injector=Guice.createInjector(new AbstractModule(){
@Override protected void configure(){
Properties properties=new Properties();
properties.setProperty(Configuration.SERVER_PERSISTENCE_TYPE_KEY,"in-memory");
properties.setProperty(Configuration.METADATA_DIR_PATH,"src/test/resources/stacks");
properties.setProperty(Configuration.SERVER_VERSION_FILE,"../version");
properties.setProperty(Configuration.OS_VERSION_KEY,OS_TYPE);
properties.setProperty(Configuration.SHARED_RESOURCES_DIR_KEY,"src/test/resources/");
try {
install(new ControllerModule(properties));
}
catch ( Exception e) {
throw new RuntimeException(e);
}
}
}
);
injector.getInstance(GuiceJpaInitializer.class);
try {
AmbariManagementController amc=injector.getInstance(AmbariManagementController.class);
Clusters clusters=injector.getInstance(Clusters.class);
clusters.addHost(HOST1);
Host host=clusters.getHost(HOST1);
setOsFamily(host,"redhat","5.9");
host.persist();
ClusterRequest clusterRequest=new ClusterRequest(null,CLUSTER_NAME,STACK_ID,null);
amc.createCluster(clusterRequest);
Set serviceRequests=new HashSet();
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"HDFS",null));
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"MAPREDUCE2",null));
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"YARN",null));
ServiceResourceProviderTest.createServices(amc,serviceRequests);
Set serviceComponentRequests=new HashSet();
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"HDFS","NAMENODE",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"HDFS","SECONDARY_NAMENODE",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"HDFS","DATANODE",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"MAPREDUCE2","HISTORYSERVER",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"YARN","RESOURCEMANAGER",null));
serviceComponentRequests.add(new ServiceComponentRequest(CLUSTER_NAME,"YARN","NODEMANAGER",null));
ComponentResourceProviderTest.createComponents(amc,serviceComponentRequests);
Set hostRequests=new HashSet();
hostRequests.add(new HostRequest(HOST1,CLUSTER_NAME,null));
HostResourceProviderTest.createHosts(amc,hostRequests);
Set componentHostRequests=new HashSet();
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"DATANODE",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"NAMENODE",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"SECONDARY_NAMENODE",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"HISTORYSERVER",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"RESOURCEMANAGER",HOST1,null));
componentHostRequests.add(new ServiceComponentHostRequest(CLUSTER_NAME,null,"NODEMANAGER",HOST1,null));
amc.createHostComponents(componentHostRequests);
serviceRequests.clear();
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"HDFS",State.INSTALLED.name()));
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"MAPREDUCE2",State.INSTALLED.name()));
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"YARN",State.INSTALLED.name()));
ServiceResourceProviderTest.updateServices(amc,serviceRequests,mapRequestProps,true,false);
Cluster cluster=clusters.getCluster(CLUSTER_NAME);
for ( String serviceName : cluster.getServices().keySet()) {
for ( String componentName : cluster.getService(serviceName).getServiceComponents().keySet()) {
Map serviceComponentHosts=cluster.getService(serviceName).getServiceComponent(componentName).getServiceComponentHosts();
for ( Map.Entry entry : serviceComponentHosts.entrySet()) {
ServiceComponentHost cHost=entry.getValue();
cHost.handleEvent(new ServiceComponentHostInstallEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis(),STACK_ID));
cHost.handleEvent(new ServiceComponentHostOpSucceededEvent(cHost.getServiceComponentName(),cHost.getHostName(),System.currentTimeMillis()));
}
}
}
serviceRequests.clear();
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"HDFS",State.STARTED.name()));
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"MAPREDUCE2",State.STARTED.name()));
serviceRequests.add(new ServiceRequest(CLUSTER_NAME,"YARN",State.STARTED.name()));
RequestStatusResponse response=ServiceResourceProviderTest.updateServices(amc,serviceRequests,mapRequestProps,true,false);
Collection hdfsSmokeTasks=CollectionUtils.select(response.getTasks(),new RolePredicate(HDFS_SERVICE_CHECK_ROLE));
org.junit.Assert.assertEquals(1,hdfsSmokeTasks.size());
Collection mapreduce2SmokeTasks=CollectionUtils.select(response.getTasks(),new RolePredicate(MAPREDUCE2_SERVICE_CHECK_ROLE));
org.junit.Assert.assertEquals(1,mapreduce2SmokeTasks.size());
Collection yarnSmokeTasks=CollectionUtils.select(response.getTasks(),new RolePredicate(YARN_SERVICE_CHECK_ROLE));
org.junit.Assert.assertEquals(1,yarnSmokeTasks.size());
}
finally {
injector.getInstance(PersistService.class).stop();
}
}
BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createServiceComponent(clusterName,serviceName,componentName1,State.INIT);
createServiceComponent(clusterName,serviceName,componentName2,State.INIT);
createServiceComponent(clusterName,serviceName,componentName3,State.INIT);
String host1="h1";
String host2="h2";
addHostToCluster(host1,clusterName);
addHostToCluster(host2,clusterName);
createServiceComponentHost(clusterName,null,componentName1,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName1).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName3).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName3).getServiceComponentHost(host2));
ServiceRequest r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
Set requests=new HashSet();
requests.add(r);
ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertEquals(State.INSTALLED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
r=new ServiceRequest(clusterName,serviceName,State.STARTED.toString());
requests.clear();
requests.add(r);
ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.STARTED);
}
}
Assert.assertEquals(State.STARTED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
if (sc.getName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED,sc.getDesiredState());
}
else {
Assert.assertEquals(State.STARTED,sc.getDesiredState());
}
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (sch.getServiceComponentName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
}
else {
Assert.assertEquals(State.STARTED,sch.getDesiredState());
}
}
}
Map configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1, cr2, cr3, cr4, cr5, cr6, cr7, cr8;
cr1=new ConfigurationRequest(clusterName,"typeA","v1",configs,null);
cr2=new ConfigurationRequest(clusterName,"typeB","v1",configs,null);
cr3=new ConfigurationRequest(clusterName,"typeC","v1",configs,null);
cr4=new ConfigurationRequest(clusterName,"typeD","v1",configs,null);
cr5=new ConfigurationRequest(clusterName,"typeA","v2",configs,null);
cr6=new ConfigurationRequest(clusterName,"typeB","v2",configs,null);
cr7=new ConfigurationRequest(clusterName,"typeC","v2",configs,null);
cr8=new ConfigurationRequest(clusterName,"typeE","v1",configs,null);
controller.createConfiguration(cr1);
controller.createConfiguration(cr2);
controller.createConfiguration(cr3);
controller.createConfiguration(cr4);
controller.createConfiguration(cr5);
controller.createConfiguration(cr6);
controller.createConfiguration(cr7);
controller.createConfiguration(cr8);
Cluster cluster=clusters.getCluster(clusterName);
Service s=cluster.getService(serviceName);
ServiceComponent sc1=s.getServiceComponent(componentName1);
ServiceComponent sc2=s.getServiceComponent(componentName2);
ServiceComponentHost sch1=sc1.getServiceComponentHost(host1);
Set schReqs=new HashSet();
Set scReqs=new HashSet();
Set sReqs=new HashSet();
Map configVersions=new HashMap();
configVersions.clear();
configVersions.put("typeA","v1");
configVersions.put("typeB","v1");
configVersions.put("typeC","v1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,null));
Assert.assertNull(updateHostComponents(schReqs,Collections.emptyMap(),true));
configVersions.clear();
configVersions.put("typeC","v1");
configVersions.put("typeD","v1");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName,serviceName,componentName2,null));
Assert.assertNull(ComponentResourceProviderTest.updateComponents(controller,scReqs,Collections.emptyMap(),true));
configVersions.clear();
configVersions.put("typeA","v2");
configVersions.put("typeC","v2");
configVersions.put("typeE","v1");
sReqs.clear();
sReqs.add(new ServiceRequest(clusterName,serviceName,null));
Assert.assertNull(ServiceResourceProviderTest.updateServices(controller,sReqs,mapRequestProps,true,false));
configVersions.clear();
configVersions.put("typeA","v1");
configVersions.put("typeB","v1");
configVersions.put("typeC","v1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,null));
Assert.assertNull(updateHostComponents(schReqs,Collections.emptyMap(),true));
configVersions.clear();
configVersions.put("typeC","v2");
configVersions.put("typeD","v1");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName,serviceName,componentName1,null));
Assert.assertNull(ComponentResourceProviderTest.updateComponents(controller,scReqs,Collections.emptyMap(),true));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier r=controller.getUsers(Collections.singleton(new UserRequest("user1")));
Assert.assertEquals(1,r.size());
UserResponse resp=r.iterator().next();
Assert.assertEquals("user1",resp.getUsername());
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier (){
{
add("h1");
add("h2");
add("h3");
}
}
,"centos5");
Service s1=serviceFactory.createNew(c1,"HDFS");
Service s2=serviceFactory.createNew(c1,"MAPREDUCE");
Service s3=serviceFactory.createNew(c1,"HBASE");
c1.addService(s1);
c1.addService(s2);
c1.addService(s3);
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
s1.persist();
s2.persist();
s3.persist();
ServiceComponent sc1=serviceComponentFactory.createNew(s1,"DATANODE");
ServiceComponent sc2=serviceComponentFactory.createNew(s1,"NAMENODE");
ServiceComponent sc3=serviceComponentFactory.createNew(s3,"HBASE_REGIONSERVER");
s1.addServiceComponent(sc1);
s1.addServiceComponent(sc2);
s3.addServiceComponent(sc3);
sc1.setDesiredState(State.UNINSTALLED);
sc3.setDesiredState(State.UNINSTALLED);
sc1.persist();
sc2.persist();
sc3.persist();
ServiceComponentHost sch1=serviceComponentHostFactory.createNew(sc1,"h1");
ServiceComponentHost sch2=serviceComponentHostFactory.createNew(sc1,"h2");
ServiceComponentHost sch3=serviceComponentHostFactory.createNew(sc1,"h3");
ServiceComponentHost sch4=serviceComponentHostFactory.createNew(sc2,"h1");
ServiceComponentHost sch5=serviceComponentHostFactory.createNew(sc2,"h2");
ServiceComponentHost sch6=serviceComponentHostFactory.createNew(sc3,"h3");
sc1.addServiceComponentHost(sch1);
sc1.addServiceComponentHost(sch2);
sc1.addServiceComponentHost(sch3);
sc2.addServiceComponentHost(sch4);
sc2.addServiceComponentHost(sch5);
sc3.addServiceComponentHost(sch6);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INIT);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.UNINSTALLED);
sch1.persist();
sch2.persist();
sch3.persist();
sch4.persist();
sch5.persist();
sch6.persist();
ServiceComponentHostRequest r=new ServiceComponentHostRequest(null,null,null,null,null);
try {
controller.getHostComponents(Collections.singleton(r));
fail("Expected failure for invalid cluster");
}
catch ( Exception e) {
}
r=new ServiceComponentHostRequest(c1.getClusterName(),null,null,null,null);
Set resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(6,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),s1.getName(),null,null,null);
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(5,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),null,sc3.getName(),null,null);
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),null,null,"h2",null);
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),null,null,null,State.UNINSTALLED.toString());
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),s1.getName(),null,null,State.INIT.toString());
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(2,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),null,sc3.getName(),null,State.INSTALLED.toString());
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(0,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),null,null,"h2",State.INIT.toString());
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),s3.getName(),null,"h1",null);
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(0,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),s3.getName(),sc3.getName(),"h3",State.INSTALLED.toString());
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(0,resps.size());
r=new ServiceComponentHostRequest(c1.getClusterName(),s3.getName(),sc3.getName(),"h3",null);
resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
ServiceComponentHostRequest r1, r2, r3;
r1=new ServiceComponentHostRequest(c1.getClusterName(),null,null,"h3",null);
r2=new ServiceComponentHostRequest(c1.getClusterName(),s3.getName(),sc3.getName(),"h2",null);
r3=new ServiceComponentHostRequest(c1.getClusterName(),null,null,"h2",null);
Set reqs=new HashSet();
reqs.addAll(Arrays.asList(r1,r2,r3));
resps=controller.getHostComponents(reqs);
Assert.assertEquals(4,resps.size());
}
UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier set1=new HashSet();
try {
set1.clear();
ServiceComponentHostRequest rInvalid=new ServiceComponentHostRequest(null,null,null,null,null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid requests");
}
catch ( IllegalArgumentException e) {
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid=new ServiceComponentHostRequest("foo",null,null,null,null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid requests");
}
catch ( IllegalArgumentException e) {
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid=new ServiceComponentHostRequest("foo","HDFS",null,null,null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid requests");
}
catch ( IllegalArgumentException e) {
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid=new ServiceComponentHostRequest("foo","HDFS","NAMENODE",null,null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid requests");
}
catch ( IllegalArgumentException e) {
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h1",null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid cluster");
}
catch ( ParentObjectNotFoundException e) {
}
clusters.addCluster("foo",new StackId("HDP-0.2"));
clusters.addCluster("c1",new StackId("HDP-0.2"));
clusters.addCluster("c2",new StackId("HDP-0.2"));
Cluster foo=clusters.getCluster("foo");
Cluster c1=clusters.getCluster("c1");
Cluster c2=clusters.getCluster("c2");
StackId stackId=new StackId("HDP-0.2");
helper.getOrCreateRepositoryVersion(stackId,stackId.getStackVersion());
foo.setDesiredStackVersion(stackId);
foo.setCurrentStackVersion(stackId);
foo.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
foo.transitionClusterVersion(stackId,stackId.getStackVersion(),RepositoryVersionState.CURRENT);
stackId=new StackId("HDP-0.2");
c1.setDesiredStackVersion(stackId);
c1.setCurrentStackVersion(stackId);
c1.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
c1.transitionClusterVersion(stackId,stackId.getStackVersion(),RepositoryVersionState.CURRENT);
stackId=new StackId("HDP-0.2");
c2.setDesiredStackVersion(stackId);
c2.setCurrentStackVersion(stackId);
c2.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
c2.transitionClusterVersion(stackId,stackId.getStackVersion(),RepositoryVersionState.CURRENT);
try {
set1.clear();
ServiceComponentHostRequest rInvalid=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h1",null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid service");
}
catch ( IllegalArgumentException e) {
}
Service s1=serviceFactory.createNew(foo,"HDFS");
foo.addService(s1);
s1.persist();
Service s2=serviceFactory.createNew(c1,"HDFS");
c1.addService(s2);
s2.persist();
Service s3=serviceFactory.createNew(c2,"HDFS");
c2.addService(s3);
s3.persist();
try {
set1.clear();
ServiceComponentHostRequest rInvalid=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h1",null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid service");
}
catch ( AmbariException e) {
}
ServiceComponent sc1=serviceComponentFactory.createNew(s1,"NAMENODE");
s1.addServiceComponent(sc1);
sc1.persist();
ServiceComponent sc2=serviceComponentFactory.createNew(s2,"NAMENODE");
s2.addServiceComponent(sc2);
sc2.persist();
ServiceComponent sc3=serviceComponentFactory.createNew(s3,"NAMENODE");
s3.addServiceComponent(sc3);
sc3.persist();
try {
set1.clear();
ServiceComponentHostRequest rInvalid=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h1",null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid host");
}
catch ( AmbariException e) {
}
clusters.addHost("h1");
Host h1=clusters.getHost("h1");
h1.setIPv4("ipv41");
h1.setIPv6("ipv61");
setOsFamily(h1,"redhat","6.3");
h1.persist();
clusters.addHost("h2");
Host h2=clusters.getHost("h2");
h2.setIPv4("ipv42");
h2.setIPv6("ipv62");
setOsFamily(h2,"redhat","6.3");
h2.persist();
clusters.addHost("h3");
Host h3=clusters.getHost("h3");
h3.setIPv4("ipv43");
h3.setIPv6("ipv63");
setOsFamily(h3,"redhat","6.3");
h3.persist();
try {
set1.clear();
ServiceComponentHostRequest rInvalid=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h1",null);
set1.add(rInvalid);
controller.createHostComponents(set1);
fail("Expected failure for invalid host cluster mapping");
}
catch ( AmbariException e) {
}
Set hostnames=new HashSet();
hostnames.add("h1");
hostnames.add("h2");
hostnames.add("h3");
clusters.mapHostsToCluster(hostnames,"foo");
clusters.mapHostsToCluster(hostnames,"c1");
clusters.mapHostsToCluster(hostnames,"c2");
set1.clear();
ServiceComponentHostRequest valid=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h1",null);
set1.add(valid);
controller.createHostComponents(set1);
try {
set1.clear();
ServiceComponentHostRequest rInvalid1=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h2",null);
ServiceComponentHostRequest rInvalid2=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h2",null);
set1.add(rInvalid1);
set1.add(rInvalid2);
controller.createHostComponents(set1);
fail("Expected failure for dup requests");
}
catch ( DuplicateResourceException e) {
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid1=new ServiceComponentHostRequest("c1","HDFS","NAMENODE","h2",null);
ServiceComponentHostRequest rInvalid2=new ServiceComponentHostRequest("c2","HDFS","NAMENODE","h3",null);
set1.add(rInvalid1);
set1.add(rInvalid2);
controller.createHostComponents(set1);
fail("Expected failure for multiple clusters");
}
catch ( IllegalArgumentException e) {
}
try {
set1.clear();
ServiceComponentHostRequest rInvalid1=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h1",null);
ServiceComponentHostRequest rInvalid2=new ServiceComponentHostRequest("foo","HDFS","NAMENODE","h2",null);
set1.add(rInvalid1);
set1.add(rInvalid2);
controller.createHostComponents(set1);
fail("Expected failure for already existing");
}
catch ( DuplicateResourceException e) {
}
Assert.assertEquals(1,foo.getServiceComponentHosts("h1").size());
Assert.assertEquals(0,foo.getServiceComponentHosts("h2").size());
Assert.assertEquals(0,foo.getServiceComponentHosts("h3").size());
set1.clear();
ServiceComponentHostRequest valid1=new ServiceComponentHostRequest("c1","HDFS","NAMENODE","h1",null);
set1.add(valid1);
controller.createHostComponents(set1);
set1.clear();
ServiceComponentHostRequest valid2=new ServiceComponentHostRequest("c2","HDFS","NAMENODE","h1",null);
set1.add(valid2);
controller.createHostComponents(set1);
Assert.assertEquals(1,foo.getServiceComponentHosts("h1").size());
Assert.assertEquals(1,c1.getServiceComponentHosts("h1").size());
Assert.assertEquals(1,c2.getServiceComponentHosts("h1").size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier controllerCapture=new Capture();
Clusters clusters=createNiceMock(Clusters.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
Cluster cluster=createNiceMock(Cluster.class);
Service service1=createNiceMock(Service.class);
Service service2=createNiceMock(Service.class);
ServiceResponse response=createNiceMock(ServiceResponse.class);
ServiceResponse response2=createNiceMock(ServiceResponse.class);
ServiceRequest request1=new ServiceRequest("cluster1","service1",null);
ServiceRequest request2=new ServiceRequest("cluster1","service2",null);
ServiceRequest request3=new ServiceRequest("cluster1","service3",null);
ServiceRequest request4=new ServiceRequest("cluster1","service4",null);
Set setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
setRequests.add(request4);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createStrictMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster).times(4);
expect(cluster.getService("service1")).andReturn(service1);
expect(cluster.getService("service2")).andThrow(new ServiceNotFoundException("cluster1","service2"));
expect(cluster.getService("service3")).andThrow(new ServiceNotFoundException("cluster1","service3"));
expect(cluster.getService("service4")).andReturn(service2);
expect(service1.convertToResponse()).andReturn(response);
expect(service2.convertToResponse()).andReturn(response2);
replay(maintHelper,injector,clusters,cluster,service1,service2,response,response2);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
Set setResponses=ServiceResourceProviderTest.getServices(controller,setRequests);
assertSame(controller,controllerCapture.getValue());
assertEquals(2,setResponses.size());
assertTrue(setResponses.contains(response));
assertTrue(setResponses.contains(response2));
verify(injector,clusters,cluster,service1,service2,response,response2);
}
APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier configs=new HashMap();
Map properties=new HashMap();
Map> propertiesAttributes=new HashMap>();
properties.put("a","a1");
properties.put("b","b1");
Config c1=new ConfigImpl(cluster,"hdfs-site",properties,propertiesAttributes,injector);
properties.put("c","c1");
properties.put("d","d1");
Config c2=new ConfigImpl(cluster,"core-site",properties,propertiesAttributes,injector);
Config c3=new ConfigImpl(cluster,"foo-site",properties,propertiesAttributes,injector);
Map mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
c1.setTag("v1");
c2.setTag("v1");
c3.setTag("v1");
cluster.addConfig(c1);
cluster.addConfig(c2);
cluster.addConfig(c3);
c1.persist();
c2.persist();
c3.persist();
configs.put(c1.getType(),c1);
configs.put(c2.getType(),c2);
ServiceRequest r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
Set requests=new HashSet();
requests.add(r);
RequestStatusResponse trackAction=ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertEquals(State.INSTALLED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
Assert.assertEquals(State.INSTALLED,sc.getDesiredState());
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
Assert.assertEquals(State.INIT,sch.getState());
}
}
List taskStatuses=trackAction.getTasks();
Assert.assertEquals(5,taskStatuses.size());
boolean foundH1NN=false;
boolean foundH1DN=false;
boolean foundH2DN=false;
boolean foundH1CLT=false;
boolean foundH2CLT=false;
for ( ShortTaskStatus taskStatus : taskStatuses) {
LOG.debug("Task dump :" + taskStatus.toString());
Assert.assertEquals(RoleCommand.INSTALL.toString(),taskStatus.getCommand());
Assert.assertEquals(HostRoleStatus.PENDING.toString(),taskStatus.getStatus());
if (taskStatus.getHostName().equals("h1")) {
if (Role.NAMENODE.toString().equals(taskStatus.getRole())) {
foundH1NN=true;
}
else if (Role.DATANODE.toString().equals(taskStatus.getRole())) {
foundH1DN=true;
}
else if (Role.HDFS_CLIENT.toString().equals(taskStatus.getRole())) {
foundH1CLT=true;
}
else {
fail("Found invalid role for host h1");
}
}
else if (taskStatus.getHostName().equals("h2")) {
if (Role.DATANODE.toString().equals(taskStatus.getRole())) {
foundH2DN=true;
}
else if (Role.HDFS_CLIENT.toString().equals(taskStatus.getRole())) {
foundH2CLT=true;
}
else {
fail("Found invalid role for host h2");
}
}
else {
fail("Found invalid host in task list");
}
}
Assert.assertTrue(foundH1DN && foundH1NN && foundH2DN&& foundH1CLT&& foundH2CLT);
List stages=actionDB.getAllStages(trackAction.getRequestId());
Assert.assertEquals(1,stages.size());
for ( Stage stage : stages) {
LOG.info("Stage Details for Install Service" + ", stageId=" + stage.getStageId() + ", actionId="+ stage.getActionId());
for ( String host : stage.getHosts()) {
for ( ExecutionCommandWrapper ecw : stage.getExecutionCommands(host)) {
Assert.assertFalse(ecw.getExecutionCommand().getHostLevelParams().get("repo_info").isEmpty());
}
}
}
org.apache.ambari.server.controller.spi.Request request=PropertyHelper.getReadRequest(TaskResourceProvider.TASK_CLUSTER_NAME_PROPERTY_ID,TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID,TaskResourceProvider.TASK_STAGE_ID_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID).equals(trackAction.getRequestId()).toPredicate();
List entities=hostRoleCommandDAO.findAll(request,predicate);
Assert.assertEquals(5,entities.size());
predicate=new PredicateBuilder().property(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID).equals(trackAction.getRequestId()).and().property(TaskResourceProvider.TASK_ID_PROPERTY_ID).equals(1L).toPredicate();
entities=hostRoleCommandDAO.findAll(request,predicate);
Assert.assertEquals(1,entities.size());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
sch.setState(State.INSTALLED);
}
}
r=new ServiceRequest(clusterName,serviceName,State.STARTED.toString());
requests.clear();
requests.add(r);
trackAction=ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertEquals(State.STARTED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
if (sc.getName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED,sc.getDesiredState());
}
else {
Assert.assertEquals(State.STARTED,sc.getDesiredState());
}
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (sch.getServiceComponentName().equals("HDFS_CLIENT")) {
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
}
else {
Assert.assertEquals(State.STARTED,sch.getDesiredState());
}
}
}
stages=actionDB.getAllStages(trackAction.getRequestId());
Assert.assertEquals(2,stages.size());
StringBuilder sb=new StringBuilder();
clusters.debugDump(sb);
LOG.info("Cluster Dump: " + sb.toString());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
if (sc.isClientComponent()) {
sch.setState(State.INSTALLED);
}
else {
sch.setState(State.INSTALL_FAILED);
}
}
}
r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
requests.clear();
requests.add(r);
trackAction=ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertEquals(State.INSTALLED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponent sc : clusters.getCluster(clusterName).getService(serviceName).getServiceComponents().values()) {
Assert.assertEquals(State.INSTALLED,sc.getDesiredState());
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
}
}
stages=actionDB.getAllStages(trackAction.getRequestId());
Assert.assertEquals(1,stages.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier responsesWithParams=controller.getStackVersions(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( StackVersionResponse responseWithParams : responsesWithParams) {
Assert.assertTrue(responseWithParams.isActive());
}
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier response=ComponentResourceProviderTest.getComponents(controller,Collections.singleton(r));
Assert.assertEquals(1,response.size());
ServiceComponentResponse sc=response.iterator().next();
Assert.assertEquals(State.INIT.toString(),sc.getDesiredState());
Assert.assertEquals(componentName,sc.getComponentName());
Assert.assertEquals(clusterName,sc.getClusterName());
Assert.assertEquals(serviceName,sc.getServiceName());
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier set1=new HashSet();
ServiceComponentHostRequest r1=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host1,State.INIT.toString());
ServiceComponentHostRequest r2=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host1,State.INIT.toString());
ServiceComponentHostRequest r3=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host2,State.INIT.toString());
ServiceComponentHostRequest r4=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host2,State.INIT.toString());
ServiceComponentHostRequest r5=new ServiceComponentHostRequest(clusterName,serviceName1,componentName3,host1,State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
set1.add(r4);
set1.add(r5);
controller.createHostComponents(set1);
Cluster c1=clusters.getCluster(clusterName);
Service s1=c1.getService(serviceName1);
ServiceComponent sc1=s1.getServiceComponent(componentName1);
ServiceComponent sc2=s1.getServiceComponent(componentName2);
ServiceComponent sc3=s1.getServiceComponent(componentName3);
ServiceComponentHost sch1=sc1.getServiceComponentHost(host1);
ServiceComponentHost sch2=sc2.getServiceComponentHost(host1);
ServiceComponentHost sch3=sc1.getServiceComponentHost(host2);
ServiceComponentHost sch4=sc2.getServiceComponentHost(host2);
ServiceComponentHost sch5=sc3.getServiceComponentHost(host1);
s1.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.INIT);
sc2.setDesiredState(State.INIT);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INSTALLED);
sch3.setDesiredState(State.STARTED);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.INSTALLED);
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.STARTED);
sch4.setState(State.INSTALLED);
sch5.setState(State.UNKNOWN);
Set reqs=new HashSet();
ServiceComponentRequest req1, req2, req3;
req1=new ServiceComponentRequest(clusterName,serviceName1,sc3.getName(),State.INSTALLED.toString());
reqs.add(req1);
ComponentResourceProviderTest.updateComponents(controller,reqs,Collections.emptyMap(),true);
try {
reqs.clear();
req1=new ServiceComponentRequest(clusterName,serviceName1,sc1.getName(),State.INIT.toString());
reqs.add(req1);
ComponentResourceProviderTest.updateComponents(controller,reqs,Collections.emptyMap(),true);
fail("Expected failure for invalid state update");
}
catch ( Exception e) {
}
s1.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INSTALLED);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.INIT);
sch2.setDesiredState(State.INIT);
sch3.setDesiredState(State.INIT);
sch4.setDesiredState(State.INIT);
sch5.setDesiredState(State.INIT);
sch1.setState(State.INIT);
sch2.setState(State.INSTALLED);
sch3.setState(State.INIT);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
try {
reqs.clear();
req1=new ServiceComponentRequest(clusterName,serviceName1,sc1.getName(),State.STARTED.toString());
reqs.add(req1);
ComponentResourceProviderTest.updateComponents(controller,reqs,Collections.emptyMap(),true);
fail("Expected failure for invalid state update");
}
catch ( Exception e) {
}
s1.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INIT);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.INIT);
sch2.setDesiredState(State.INIT);
sch3.setDesiredState(State.INIT);
sch4.setDesiredState(State.INIT);
sch5.setDesiredState(State.INIT);
sch1.setState(State.STARTED);
sch2.setState(State.INIT);
sch3.setState(State.INSTALLED);
sch4.setState(State.STARTED);
sch5.setState(State.INIT);
reqs.clear();
req1=new ServiceComponentRequest(clusterName,serviceName1,sc1.getName(),State.INSTALLED.toString());
req2=new ServiceComponentRequest(clusterName,serviceName1,sc2.getName(),State.INSTALLED.toString());
req3=new ServiceComponentRequest(clusterName,serviceName1,sc3.getName(),State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
reqs.add(req3);
RequestStatusResponse trackAction=ComponentResourceProviderTest.updateComponents(controller,reqs,Collections.emptyMap(),true);
Assert.assertEquals(State.INSTALLED,s1.getDesiredState());
Assert.assertEquals(State.INSTALLED,sc1.getDesiredState());
Assert.assertEquals(State.INSTALLED,sc2.getDesiredState());
Assert.assertEquals(State.INSTALLED,sc3.getDesiredState());
Assert.assertEquals(State.INSTALLED,sch1.getDesiredState());
Assert.assertEquals(State.INSTALLED,sch2.getDesiredState());
Assert.assertEquals(State.INSTALLED,sch3.getDesiredState());
Assert.assertEquals(State.INSTALLED,sch4.getDesiredState());
Assert.assertEquals(State.INSTALLED,sch5.getDesiredState());
Assert.assertEquals(State.STARTED,sch1.getState());
Assert.assertEquals(State.INIT,sch2.getState());
Assert.assertEquals(State.INSTALLED,sch3.getState());
Assert.assertEquals(State.STARTED,sch4.getState());
Assert.assertEquals(State.INIT,sch5.getState());
long requestId=trackAction.getRequestId();
List stages=actionDB.getAllStages(requestId);
Assert.assertTrue(!stages.isEmpty());
for ( Stage stage : stages) {
LOG.debug("Stage dump: " + stage.toString());
}
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.INSTALLED);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
reqs.clear();
req1=new ServiceComponentRequest(clusterName,serviceName1,sc1.getName(),State.INSTALLED.toString());
req2=new ServiceComponentRequest(clusterName,serviceName1,sc2.getName(),State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
trackAction=ComponentResourceProviderTest.updateComponents(controller,reqs,Collections.emptyMap(),true);
Assert.assertNull(trackAction);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier params=new HashMap(){
{
put("excluded_hosts","h2");
put("align_maintenance_state","true");
}
}
;
RequestResourceFilter resourceFilter=new RequestResourceFilter("HBASE","HBASE_MASTER",null);
List resourceFilters=new ArrayList();
resourceFilters.add(resourceFilter);
ExecuteActionRequest request=new ExecuteActionRequest(clusterName,"DECOMMISSION",null,resourceFilters,level,params,false);
Map requestProperties=new HashMap();
requestProperties.put(REQUEST_CONTEXT_PROPERTY,"Called from a test");
RequestStatusResponse response=controller.createAction(request,requestProperties);
List storedTasks=actionDB.getRequestTasks(response.getRequestId());
ExecutionCommand execCmd=storedTasks.get(0).getExecutionCommandWrapper().getExecutionCommand();
Assert.assertNotNull(storedTasks);
Assert.assertEquals(1,storedTasks.size());
Assert.assertEquals(HostComponentAdminState.DECOMMISSIONED,scHost.getComponentAdminState());
Assert.assertEquals(MaintenanceState.ON,scHost.getMaintenanceState());
HostRoleCommand command=storedTasks.get(0);
Assert.assertTrue("DECOMMISSION, Excluded: h2".equals(command.getCommandDetail()));
Assert.assertTrue("DECOMMISSION".equals(command.getCustomCommandName()));
Map cmdParams=command.getExecutionCommandWrapper().getExecutionCommand().getCommandParams();
Assert.assertTrue(cmdParams.containsKey("mark_draining_only"));
Assert.assertEquals("false",cmdParams.get("mark_draining_only"));
Assert.assertEquals(Role.HBASE_MASTER,command.getRole());
Assert.assertEquals(RoleCommand.CUSTOM_COMMAND,command.getRoleCommand());
Assert.assertEquals("DECOMMISSION",execCmd.getHostLevelParams().get("custom_command"));
assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
s.getServiceComponent("HBASE_REGIONSERVER").getServiceComponentHost("h2").setState(State.INSTALLED);
params=new HashMap(){
{
put("excluded_hosts","h2");
put("mark_draining_only","true");
put("slave_type","HBASE_REGIONSERVER");
put("align_maintenance_state","true");
}
}
;
resourceFilter=new RequestResourceFilter("HBASE","HBASE_MASTER",null);
ArrayList filters=new ArrayList();
filters.add(resourceFilter);
request=new ExecuteActionRequest(clusterName,"DECOMMISSION",null,filters,level,params,false);
response=controller.createAction(request,requestProperties);
storedTasks=actionDB.getRequestTasks(response.getRequestId());
execCmd=storedTasks.get(0).getExecutionCommandWrapper().getExecutionCommand();
Assert.assertNotNull(storedTasks);
Assert.assertEquals(1,storedTasks.size());
Assert.assertEquals(HostComponentAdminState.DECOMMISSIONED,scHost.getComponentAdminState());
Assert.assertEquals(MaintenanceState.ON,scHost.getMaintenanceState());
command=storedTasks.get(0);
Assert.assertEquals("DECOMMISSION",execCmd.getHostLevelParams().get("custom_command"));
Assert.assertTrue("DECOMMISSION, Excluded: h2".equals(command.getCommandDetail()));
Assert.assertTrue("DECOMMISSION".equals(command.getCustomCommandName()));
cmdParams=command.getExecutionCommandWrapper().getExecutionCommand().getCommandParams();
Assert.assertTrue(cmdParams.containsKey("mark_draining_only"));
Assert.assertEquals("true",cmdParams.get("mark_draining_only"));
assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
params=new HashMap(){
{
put("included_hosts","h2");
}
}
;
request=new ExecuteActionRequest(clusterName,"DECOMMISSION",null,resourceFilters,level,params,false);
response=controller.createAction(request,requestProperties);
storedTasks=actionDB.getRequestTasks(response.getRequestId());
execCmd=storedTasks.get(0).getExecutionCommandWrapper().getExecutionCommand();
Assert.assertNotNull(storedTasks);
Assert.assertEquals(1,storedTasks.size());
Assert.assertEquals(HostComponentAdminState.INSERVICE,scHost.getComponentAdminState());
Assert.assertEquals(MaintenanceState.ON,scHost.getMaintenanceState());
command=storedTasks.get(0);
Assert.assertTrue("DECOMMISSION, Included: h2".equals(command.getCommandDetail()));
Assert.assertTrue("DECOMMISSION".equals(command.getCustomCommandName()));
cmdParams=command.getExecutionCommandWrapper().getExecutionCommand().getCommandParams();
Assert.assertTrue(cmdParams.containsKey("mark_draining_only"));
Assert.assertEquals("false",cmdParams.get("mark_draining_only"));
assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
Assert.assertTrue(cmdParams.containsKey("excluded_hosts"));
Assert.assertEquals("",cmdParams.get("excluded_hosts"));
Assert.assertEquals(Role.HBASE_MASTER,command.getRole());
Assert.assertEquals(RoleCommand.CUSTOM_COMMAND,command.getRoleCommand());
Assert.assertEquals("DECOMMISSION",execCmd.getHostLevelParams().get("custom_command"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resp=controller.getClusters(Collections.singleton(r));
Assert.assertEquals(1,resp.size());
ClusterResponse resp1=resp.iterator().next();
Assert.assertEquals(c1.getClusterId(),resp1.getClusterId().longValue());
Assert.assertEquals(c1.getClusterName(),resp1.getClusterName());
Assert.assertEquals(c1.getDesiredStackVersion().getStackId(),resp1.getDesiredStackVersion());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
add("h1");
add("h2");
add("h3");
}
}
,"centos6");
Cluster cluster=clusters.getCluster("c1");
cluster.setDesiredStackVersion(new StackId("HDP-2.0.6"));
cluster.setCurrentStackVersion(new StackId("HDP-2.0.6"));
ConfigFactory cf=injector.getInstance(ConfigFactory.class);
Config config1=cf.createNew(cluster,"global",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config1.setTag("version1");
Config config2=cf.createNew(cluster,"core-site",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config2.setTag("version1");
cluster.addConfig(config1);
cluster.addConfig(config2);
Service hdfs=cluster.addService("HDFS");
hdfs.persist();
Service mapred=cluster.addService("YARN");
mapred.persist();
hdfs.addServiceComponent(Role.HDFS_CLIENT.name()).persist();
hdfs.addServiceComponent(Role.NAMENODE.name()).persist();
hdfs.addServiceComponent(Role.DATANODE.name()).persist();
mapred.addServiceComponent(Role.RESOURCEMANAGER.name()).persist();
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.NAMENODE.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost("h2").persist();
controller.getAmbariMetaInfo().addActionDefinition(new ActionDefinition("a1",ActionType.SYSTEM,"","HDFS","","Some custom action.",TargetHostType.ALL,Short.valueOf("10010")));
Map params=new HashMap(){
{
put("test","test");
}
}
;
Map requestProperties=new HashMap();
requestProperties.put(REQUEST_CONTEXT_PROPERTY,"Called from a test");
List resourceFilters=new ArrayList();
ArrayList hosts=new ArrayList(){
{
add("h2");
}
}
;
RequestResourceFilter resourceFilter1=new RequestResourceFilter("HDFS","DATANODE",hosts);
hosts=new ArrayList(){
{
add("h1");
}
}
;
RequestResourceFilter resourceFilter2=new RequestResourceFilter("HDFS","NAMENODE",hosts);
resourceFilters.add(resourceFilter1);
resourceFilters.add(resourceFilter2);
ExecuteActionRequest actionRequest=new ExecuteActionRequest("c1",null,"a1",resourceFilters,null,params,false);
RequestStatusResponse response=null;
try {
response=controller.createAction(actionRequest,requestProperties);
}
catch ( AmbariException ae) {
LOG.info("Expected exception.",ae);
Assert.assertTrue(ae.getMessage().contains("Custom action definition only " + "allows one resource filter to be specified"));
}
resourceFilters.remove(resourceFilter1);
actionRequest=new ExecuteActionRequest("c1",null,"a1",resourceFilters,null,params,false);
response=controller.createAction(actionRequest,requestProperties);
assertEquals(1,response.getTasks().size());
HostRoleCommand nnCommand=null;
for ( HostRoleCommand hrc : actionDB.getRequestTasks(response.getRequestId())) {
if (hrc.getHostName().equals("h1")) {
nnCommand=hrc;
}
}
Assert.assertNotNull(nnCommand);
ExecutionCommand cmd=nnCommand.getExecutionCommandWrapper().getExecutionCommand();
Assert.assertEquals("a1",cmd.getRole());
Assert.assertEquals("10010",cmd.getCommandParams().get("command_timeout"));
Type type=new TypeToken>(){
}
.getType();
for ( Stage stage : actionDB.getAllStages(response.getRequestId())) {
Map commandParamsStage=StageUtils.getGson().fromJson(stage.getCommandParamsStage(),type);
Assert.assertTrue(commandParamsStage.containsKey("test"));
}
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
}
InternalCallVerifier NullVerifier stages=actionDB.getAllStages(requestId);
HostRoleCommand clientReinstallCmd=null;
for ( Stage stage : stages) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getHostName().equals(host3) && hrc.getRole().toString().equals("HDFS_CLIENT")) {
clientReinstallCmd=hrc;
break;
}
}
}
Assert.assertNotNull(clientReinstallCmd);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier responses=controller.getStackServices(Collections.singleton(request));
Assert.assertEquals(11,responses.size());
StackServiceRequest requestWithParams=new StackServiceRequest(STACK_NAME,NEW_STACK_VERSION,SERVICE_NAME);
Set responsesWithParams=controller.getStackServices(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( StackServiceResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getServiceName(),SERVICE_NAME);
Assert.assertTrue(responseWithParams.getConfigTypes().size() > 0);
}
StackServiceRequest invalidRequest=new StackServiceRequest(STACK_NAME,NEW_STACK_VERSION,NON_EXT_VALUE);
try {
controller.getStackServices(Collections.singleton(invalidRequest));
}
catch ( StackAccessException e) {
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resp=ServiceResourceProviderTest.getServices(controller,Collections.singleton(r));
ServiceResponse resp1=resp.iterator().next();
Assert.assertEquals(s1.getClusterId(),resp1.getClusterId().longValue());
Assert.assertEquals(s1.getCluster().getClusterName(),resp1.getClusterName());
Assert.assertEquals(s1.getName(),resp1.getServiceName());
Assert.assertEquals("HDP-0.1",s1.getDesiredStackVersion().getStackId());
Assert.assertEquals(s1.getDesiredStackVersion().getStackId(),resp1.getDesiredStackVersion());
Assert.assertEquals(State.INSTALLED.toString(),resp1.getDesiredState());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1, cr2, cr3;
cr1=new ConfigurationRequest(clusterName,"core-site","version1",configs,null);
cr2=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
cr3=new ConfigurationRequest(clusterName,"mapred-site","version1",configs,null);
ClusterRequest crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr2));
controller.updateClusters(Collections.singleton(crReq),null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr3));
controller.updateClusters(Collections.singleton(crReq),null);
configs=new HashMap();
configs.put("a","c");
cluster=clusters.getCluster(clusterName);
final Config config=new ConfigImpl("core-site");
config.setProperties(configs);
config.setTag("version122");
Long groupId=createConfigGroup(cluster,"g1","t1",new ArrayList(){
{
add("h1");
}
}
,new ArrayList(){
{
add(config);
}
}
);
Assert.assertNotNull(groupId);
configs=new HashMap();
configs.put("a","c");
final Config config2=new ConfigImpl("mapred-site");
config2.setProperties(configs);
config2.setTag("version122");
groupId=createConfigGroup(cluster,"g2","t2",new ArrayList(){
{
add("h1");
}
}
,new ArrayList(){
{
add(config2);
}
}
);
Assert.assertNotNull(groupId);
Long requestId=installService(clusterName,serviceName1,false,false);
HostRoleCommand namenodeInstall=null;
HostRoleCommand clientInstall=null;
HostRoleCommand slaveInstall=null;
for ( Stage stage : actionDB.getAllStages(requestId)) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.NAMENODE) && hrc.getHostName().equals("h1")) {
namenodeInstall=hrc;
}
else if (hrc.getRole().equals(Role.HDFS_CLIENT) && hrc.getHostName().equals("h3")) {
clientInstall=hrc;
}
else if (hrc.getRole().equals(Role.DATANODE) && hrc.getHostName().equals("h2")) {
slaveInstall=hrc;
}
}
}
Assert.assertNotNull(namenodeInstall);
Assert.assertNotNull(clientInstall);
Assert.assertNotNull(slaveInstall);
Assert.assertTrue(namenodeInstall.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().get("core-site").containsKey("a"));
Assert.assertEquals("c",namenodeInstall.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().get("core-site").get("a"));
Assert.assertTrue(clientInstall.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().get("core-site").containsKey("a"));
Assert.assertEquals("b",clientInstall.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().get("core-site").get("a"));
Assert.assertTrue(slaveInstall.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().get("core-site").containsKey("a"));
Assert.assertEquals("b",slaveInstall.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().get("core-site").get("a"));
startService(clusterName,serviceName1,false,false);
requestId=installService(clusterName,serviceName2,false,false);
HostRoleCommand mapredInstall=null;
for ( Stage stage : actionDB.getAllStages(requestId)) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.HISTORYSERVER) && hrc.getHostName().equals("h3")) {
mapredInstall=hrc;
}
}
}
Assert.assertNotNull(mapredInstall);
Assert.assertEquals("b",mapredInstall.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().get("mapred-site").get("a"));
ConfigGroup configGroup=cluster.getConfigGroups().get(groupId);
configGroup.setHosts(new HashMap(){
{
put(3L,clusters.getHost("h3"));
}
}
);
configGroup.persist();
requestId=startService(clusterName,serviceName2,false,false);
mapredInstall=null;
for ( Stage stage : actionDB.getAllStages(requestId)) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.HISTORYSERVER) && hrc.getHostName().equals("h3")) {
mapredInstall=hrc;
}
}
}
Assert.assertNotNull(mapredInstall);
Assert.assertEquals("c",mapredInstall.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().get("mapred-site").get("a"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier responses=controller.getRepositories(Collections.singleton(request));
Assert.assertEquals(REPOS_CNT,responses.size());
RepositoryRequest requestWithParams=new RepositoryRequest(STACK_NAME,STACK_VERSION,OS_TYPE,REPO_ID);
Set responsesWithParams=controller.getRepositories(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( RepositoryResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getRepoId(),REPO_ID);
}
RepositoryRequest invalidRequest=new RepositoryRequest(STACK_NAME,STACK_VERSION,OS_TYPE,NON_EXT_VALUE);
try {
controller.getRepositories(Collections.singleton(invalidRequest));
}
catch ( StackAccessException e) {
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier configs=new HashMap();
configs.put("a","b");
ConfigurationRequest cr1;
cr1=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
ClusterRequest crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
startService(clusterName,serviceName,false,false);
cluster=clusters.getCluster(clusterName);
Service s=cluster.getService(serviceName);
Assert.assertEquals(State.STARTED,s.getDesiredState());
ServiceComponentHost scHost=s.getServiceComponent("DATANODE").getServiceComponentHost("h2");
Assert.assertEquals(HostComponentAdminState.INSERVICE,scHost.getComponentAdminState());
Map params=new HashMap(){
{
put("test","test");
put("excluded_hosts","h2");
put("align_maintenance_state","true");
}
}
;
RequestResourceFilter resourceFilter=new RequestResourceFilter("HDFS","NAMENODE",null);
ArrayList filters=new ArrayList();
filters.add(resourceFilter);
ExecuteActionRequest request=new ExecuteActionRequest(clusterName,"DECOMMISSION",null,filters,level,params,false);
Map requestProperties=new HashMap();
requestProperties.put(REQUEST_CONTEXT_PROPERTY,"Called from a test");
RequestStatusResponse response=controller.createAction(request,requestProperties);
List storedTasks=actionDB.getRequestTasks(response.getRequestId());
ExecutionCommand execCmd=storedTasks.get(0).getExecutionCommandWrapper().getExecutionCommand();
Assert.assertNotNull(storedTasks);
Assert.assertNotNull(execCmd.getConfigurationTags().get("hdfs-site"));
Assert.assertEquals(1,storedTasks.size());
Assert.assertEquals(HostComponentAdminState.DECOMMISSIONED,scHost.getComponentAdminState());
Assert.assertEquals(MaintenanceState.ON,scHost.getMaintenanceState());
HostRoleCommand command=storedTasks.get(0);
Assert.assertEquals(Role.NAMENODE,command.getRole());
Assert.assertEquals(RoleCommand.CUSTOM_COMMAND,command.getRoleCommand());
Assert.assertEquals("DECOMMISSION",execCmd.getHostLevelParams().get("custom_command"));
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
params=new HashMap(){
{
put("test","test");
put("excluded_hosts","h1");
put("align_maintenance_state","true");
}
}
;
resourceFilter=new RequestResourceFilter("HDFS","NAMENODE",null);
filters=new ArrayList();
filters.add(resourceFilter);
request=new ExecuteActionRequest(clusterName,"DECOMMISSION",null,filters,level,params,false);
response=controller.createAction(request,requestProperties);
storedTasks=actionDB.getRequestTasks(response.getRequestId());
execCmd=storedTasks.get(0).getExecutionCommandWrapper().getExecutionCommand();
Map cmdParams=execCmd.getCommandParams();
Assert.assertTrue(cmdParams.containsKey("update_exclude_file_only"));
Assert.assertTrue(cmdParams.get("update_exclude_file_only").equals("false"));
Assert.assertNotNull(storedTasks);
Assert.assertEquals(1,storedTasks.size());
Assert.assertEquals(HostComponentAdminState.DECOMMISSIONED,scHost.getComponentAdminState());
Assert.assertEquals(MaintenanceState.ON,scHost.getMaintenanceState());
Assert.assertEquals("DECOMMISSION",execCmd.getHostLevelParams().get("custom_command"));
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
createServiceComponentHost(clusterName,serviceName,componentName1,host2,null);
ServiceComponentHostRequest r=new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host2,State.INSTALLED.toString());
Set requests=new HashSet();
requests.add(r);
updateHostComponents(requests,Collections.emptyMap(),true);
s.getServiceComponent(componentName1).getServiceComponentHost(host2).setState(State.INSTALLED);
r=new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host2,State.STARTED.toString());
requests.clear();
requests.add(r);
updateHostComponents(requests,Collections.emptyMap(),true);
s.getServiceComponent(componentName1).getServiceComponentHost(host2).setState(State.STARTED);
params=new HashMap(){
{
put("test","test");
put("included_hosts","h1 , h2");
put("align_maintenance_state","true");
}
}
;
resourceFilter=new RequestResourceFilter("HDFS","NAMENODE",null);
filters=new ArrayList();
filters.add(resourceFilter);
request=new ExecuteActionRequest(clusterName,"DECOMMISSION",null,filters,level,params,false);
response=controller.createAction(request,requestProperties);
storedTasks=actionDB.getRequestTasks(response.getRequestId());
Assert.assertNotNull(storedTasks);
scHost=s.getServiceComponent("DATANODE").getServiceComponentHost("h2");
Assert.assertEquals(HostComponentAdminState.INSERVICE,scHost.getComponentAdminState());
Assert.assertEquals(MaintenanceState.OFF,scHost.getMaintenanceState());
execCmd=storedTasks.get(0).getExecutionCommandWrapper().getExecutionCommand();
Assert.assertNotNull(storedTasks);
Assert.assertEquals(2,storedTasks.size());
int countRefresh=0;
for ( HostRoleCommand hrc : storedTasks) {
Assert.assertTrue("DECOMMISSION, Included: h1,h2".equals(hrc.getCommandDetail()));
Assert.assertTrue("DECOMMISSION".equals(hrc.getCustomCommandName()));
cmdParams=hrc.getExecutionCommandWrapper().getExecutionCommand().getCommandParams();
if (!cmdParams.containsKey("update_exclude_file_only") || !cmdParams.get("update_exclude_file_only").equals("true")) {
countRefresh++;
}
}
Assert.assertEquals(2,countRefresh);
scHost.setComponentAdminState(null);
Assert.assertEquals(HostComponentAdminState.INSERVICE,scHost.getComponentAdminState());
Assert.assertEquals(MaintenanceState.OFF,scHost.getMaintenanceState());
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier r=controller.getClusters(Collections.singleton(new ClusterRequest(null,clusterName,null,null)));
Assert.assertEquals(1,r.size());
ClusterResponse c=r.iterator().next();
Assert.assertEquals(clusterName,c.getClusterName());
try {
createCluster(clusterName);
fail("Duplicate cluster creation should fail");
}
catch ( AmbariException e) {
}
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
add("h1");
add("h2");
add("h3");
}
}
,"centos6");
Cluster cluster=clusters.getCluster("c1");
cluster.setDesiredStackVersion(new StackId("HDP-2.0.6"));
cluster.setCurrentStackVersion(new StackId("HDP-2.0.6"));
ConfigFactory cf=injector.getInstance(ConfigFactory.class);
Config config1=cf.createNew(cluster,"global",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config1.setTag("version1");
Config config2=cf.createNew(cluster,"core-site",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config2.setTag("version1");
cluster.addConfig(config1);
cluster.addConfig(config2);
Service hdfs=cluster.addService("HDFS");
hdfs.persist();
Service mapred=cluster.addService("YARN");
mapred.persist();
hdfs.addServiceComponent(Role.HDFS_CLIENT.name()).persist();
hdfs.addServiceComponent(Role.NAMENODE.name()).persist();
hdfs.addServiceComponent(Role.DATANODE.name()).persist();
mapred.addServiceComponent(Role.RESOURCEMANAGER.name()).persist();
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.NAMENODE.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost("h2").persist();
mapred.getServiceComponent(Role.RESOURCEMANAGER.name()).addServiceComponentHost("h2").persist();
Map params=new HashMap(){
{
put("test","test");
}
}
;
Map requestProperties=new HashMap();
requestProperties.put(REQUEST_CONTEXT_PROPERTY,"Called from a test");
List resourceFilters=new ArrayList();
RequestResourceFilter resourceFilter=new RequestResourceFilter("HDFS",Role.DATANODE.name(),new ArrayList(){
{
add("h1");
add("h2");
}
}
);
resourceFilters.add(resourceFilter);
resourceFilter=new RequestResourceFilter("YARN",Role.RESOURCEMANAGER.name(),new ArrayList(){
{
add("h2");
}
}
);
resourceFilters.add(resourceFilter);
ExecuteActionRequest request=new ExecuteActionRequest("c1","RESTART",null,resourceFilters,null,params,false);
RequestStatusResponse response=controller.createAction(request,requestProperties);
Assert.assertEquals(3,response.getTasks().size());
List storedTasks=actionDB.getRequestTasks(response.getRequestId());
Assert.assertNotNull(storedTasks);
int expectedRestartCount=0;
for ( HostRoleCommand hrc : storedTasks) {
Assert.assertEquals("RESTART",hrc.getCustomCommandName());
if (hrc.getHostName().equals("h1") && hrc.getRole().equals(Role.DATANODE)) {
expectedRestartCount++;
}
else if (hrc.getHostName().equals("h2")) {
if (hrc.getRole().equals(Role.DATANODE)) {
expectedRestartCount++;
}
else if (hrc.getRole().equals(Role.RESOURCEMANAGER)) {
expectedRestartCount++;
}
}
}
Assert.assertEquals("Restart 2 datanodes and 1 Resourcemanager.",3,expectedRestartCount);
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
resourceFilters.clear();
resourceFilter=new RequestResourceFilter("HDFS",null,new ArrayList(){
{
add("h1");
}
}
);
resourceFilters.add(resourceFilter);
request=new ExecuteActionRequest("c1",Role.HDFS_SERVICE_CHECK.name(),null,resourceFilters,null,null,false);
response=controller.createAction(request,requestProperties);
Assert.assertEquals(1,response.getTasks().size());
storedTasks=actionDB.getRequestTasks(response.getRequestId());
Assert.assertNotNull(storedTasks);
Assert.assertEquals(Role.HDFS_SERVICE_CHECK.name(),storedTasks.get(0).getRole().name());
Assert.assertEquals("h1",storedTasks.get(0).getHostName());
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
add("h1");
add("h2");
}
}
,"centos5");
Cluster cluster=clusters.getCluster("c1");
cluster.setDesiredStackVersion(new StackId("HDP-0.1"));
cluster.setCurrentStackVersion(new StackId("HDP-0.1"));
ConfigFactory cf=injector.getInstance(ConfigFactory.class);
Config config1=cf.createNew(cluster,"global",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config1.setTag("version1");
config1.setPropertiesAttributes(new HashMap>(){
{
put("attr1",new HashMap());
}
}
);
Config config2=cf.createNew(cluster,"core-site",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config2.setTag("version1");
config2.setPropertiesAttributes(new HashMap>(){
{
put("attr2",new HashMap());
}
}
);
cluster.addConfig(config1);
cluster.addConfig(config2);
cluster.addDesiredConfig("_test",Collections.singleton(config1));
cluster.addDesiredConfig("_test",Collections.singleton(config2));
Service hdfs=cluster.addService("HDFS");
Service mapReduce=cluster.addService("MAPREDUCE");
hdfs.persist();
mapReduce.persist();
hdfs.addServiceComponent(Role.HDFS_CLIENT.name()).persist();
mapReduce.addServiceComponent(Role.MAPREDUCE_CLIENT.name()).persist();
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).addServiceComponentHost("h1").persist();
mapReduce.getServiceComponent(Role.MAPREDUCE_CLIENT.name()).addServiceComponentHost("h2").persist();
Map params=new HashMap(){
{
put("test","test");
}
}
;
ExecuteActionRequest actionRequest=new ExecuteActionRequest("c1",Role.HDFS_SERVICE_CHECK.name(),params,false);
RequestResourceFilter resourceFilter=new RequestResourceFilter("HDFS",null,null);
actionRequest.getResourceFilters().add(resourceFilter);
Map requestProperties=new HashMap();
requestProperties.put(REQUEST_CONTEXT_PROPERTY,"Called from a test");
RequestStatusResponse response=controller.createAction(actionRequest,requestProperties);
assertEquals(1,response.getTasks().size());
ShortTaskStatus task=response.getTasks().get(0);
List storedTasks=actionDB.getRequestTasks(response.getRequestId());
Stage stage=actionDB.getAllStages(response.getRequestId()).get(0);
ExecutionCommandDAO executionCommandDAO=injector.getInstance(ExecutionCommandDAO.class);
ExecutionCommandEntity commandEntity=executionCommandDAO.findByPK(task.getTaskId());
Gson gson=new Gson();
ExecutionCommand executionCommand=gson.fromJson(new StringReader(new String(commandEntity.getCommand())),ExecutionCommand.class);
assertFalse(executionCommand.getConfigurationTags().isEmpty());
assertTrue(executionCommand.getConfigurations() == null || executionCommand.getConfigurations().isEmpty());
assertEquals(1,storedTasks.size());
HostRoleCommand hostRoleCommand=storedTasks.get(0);
assertEquals("SERVICE_CHECK HDFS",hostRoleCommand.getCommandDetail());
assertNull(hostRoleCommand.getCustomCommandName());
assertEquals(task.getTaskId(),hostRoleCommand.getTaskId());
assertNotNull(actionRequest.getResourceFilters());
RequestResourceFilter requestResourceFilter=actionRequest.getResourceFilters().get(0);
assertEquals(resourceFilter.getServiceName(),hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getServiceName());
assertEquals(actionRequest.getClusterName(),hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getClusterName());
assertEquals(actionRequest.getCommandName(),hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getRole());
assertEquals(Role.HDFS_CLIENT.name(),hostRoleCommand.getEvent().getEvent().getServiceComponentName());
assertEquals(actionRequest.getParameters(),hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getRoleParams());
assertNotNull(hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getConfigurations());
assertEquals(2,hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().size());
assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),stage.getRequestContext());
assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
actionRequest=new ExecuteActionRequest("c1",Role.MAPREDUCE_SERVICE_CHECK.name(),null,false);
resourceFilter=new RequestResourceFilter("MAPREDUCE",null,null);
actionRequest.getResourceFilters().add(resourceFilter);
injector.getInstance(ActionMetadata.class).addServiceCheckAction("MAPREDUCE");
response=controller.createAction(actionRequest,requestProperties);
assertEquals(1,response.getTasks().size());
List tasks=actionDB.getRequestTasks(response.getRequestId());
assertEquals(1,tasks.size());
requestProperties.put(REQUEST_CONTEXT_PROPERTY,null);
response=controller.createAction(actionRequest,requestProperties);
assertEquals(1,response.getTasks().size());
assertEquals("",response.getRequestContext());
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier resps=ComponentResourceProviderTest.getComponents(controller,Collections.singleton(r));
Assert.assertEquals(3,resps.size());
r=new ServiceComponentRequest(c2.getClusterName(),null,null,State.UNINSTALLED.toString());
resps=ComponentResourceProviderTest.getComponents(controller,Collections.singleton(r));
Assert.assertEquals(4,resps.size());
r=new ServiceComponentRequest(c2.getClusterName(),s5.getName(),null,null);
resps=ComponentResourceProviderTest.getComponents(controller,Collections.singleton(r));
Assert.assertEquals(2,resps.size());
r=new ServiceComponentRequest(c2.getClusterName(),s4.getName(),null,State.INIT.toString());
resps=ComponentResourceProviderTest.getComponents(controller,Collections.singleton(r));
Assert.assertEquals(1,resps.size());
Assert.assertEquals(sc4.getName(),resps.iterator().next().getComponentName());
r=new ServiceComponentRequest(c2.getClusterName(),null,sc5.getName(),State.INIT.toString());
resps=ComponentResourceProviderTest.getComponents(controller,Collections.singleton(r));
Assert.assertEquals(1,resps.size());
Assert.assertEquals(sc5.getName(),resps.iterator().next().getComponentName());
r=new ServiceComponentRequest(c2.getClusterName(),s4.getName(),sc5.getName(),State.INIT.toString());
resps=ComponentResourceProviderTest.getComponents(controller,Collections.singleton(r));
Assert.assertEquals(1,resps.size());
Assert.assertEquals(sc5.getName(),resps.iterator().next().getComponentName());
ServiceComponentRequest r1, r2, r3;
Set reqs=new HashSet();
r1=new ServiceComponentRequest(c2.getClusterName(),null,null,State.UNINSTALLED.toString());
r2=new ServiceComponentRequest(c1.getClusterName(),null,null,null);
r3=new ServiceComponentRequest(c1.getClusterName(),null,null,State.INIT.toString());
reqs.addAll(Arrays.asList(r1,r2,r3));
resps=ComponentResourceProviderTest.getComponents(controller,reqs);
Assert.assertEquals(7,resps.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier responsesWithParams=controller.getStackServices(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( StackServiceResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getServiceName(),"YARN");
Assert.assertTrue(responseWithParams.getConfigTypes().containsKey("capacity-scheduler"));
}
}
UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier set1=new HashSet();
clusters.addCluster("foo",new StackId("HDP-0.1"));
ServiceRequest valid1=new ServiceRequest("foo","HDFS",null);
ServiceRequest valid2=new ServiceRequest("foo","MAPREDUCE",null);
set1.add(valid1);
set1.add(valid2);
ServiceResourceProviderTest.createServices(controller,set1);
try {
valid1=new ServiceRequest("foo","PIG",null);
valid2=new ServiceRequest("foo","MAPREDUCE",null);
set1.add(valid1);
set1.add(valid2);
ServiceResourceProviderTest.createServices(controller,set1);
fail("Expected failure for invalid services");
}
catch ( AmbariException e) {
Assert.assertTrue(checkExceptionType(e,DuplicateResourceException.class));
}
Assert.assertNotNull(clusters.getCluster("foo"));
Assert.assertEquals(2,clusters.getCluster("foo").getServices().size());
Assert.assertNotNull(clusters.getCluster("foo").getService("HDFS"));
Assert.assertNotNull(clusters.getCluster("foo").getService("MAPREDUCE"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createServiceComponentHost(clusterName,null,componentName1,host1,null);
createServiceComponentHost(clusterName,null,componentName1,host2,null);
ServiceRequest r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
Set requests=new HashSet();
requests.add(r);
RequestStatusResponse trackAction=ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertEquals(State.INSTALLED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
List stages=actionDB.getAllStages(trackAction.getRequestId());
Type type=new TypeToken>(){
}
.getType();
for ( Stage stage : stages) {
Map params=StageUtils.getGson().fromJson(stage.getHostParamsStage(),type);
Assert.assertEquals("0.1",params.get("stack_version"));
Assert.assertNotNull(params.get("jdk_location"));
Assert.assertNotNull(params.get("db_name"));
Assert.assertNotNull(params.get("mysql_jdbc_url"));
Assert.assertNotNull(params.get("oracle_jdbc_url"));
}
Map paramsCmd=stages.get(0).getOrderedHostRoleCommands().get(0).getExecutionCommandWrapper().getExecutionCommand().getHostLevelParams();
Assert.assertNotNull(paramsCmd.get("repo_info"));
Assert.assertNotNull(paramsCmd.get("clientsToUpdateConfigs"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier requestProperties=new HashMap();
requestProperties.put(REQUEST_CONTEXT_PROPERTY,"Called from a test");
Map requestParams=new HashMap();
requestParams.put("some_custom_param","abc");
List hosts=Arrays.asList(hostname1);
RequestResourceFilter resourceFilter=new RequestResourceFilter(null,null,hosts);
List resourceFilters=new ArrayList();
resourceFilters.add(resourceFilter);
ExecuteActionRequest actionRequest=new ExecuteActionRequest(null,null,"a1",resourceFilters,null,requestParams,false);
RequestStatusResponse response=controller.createAction(actionRequest,requestProperties);
assertEquals(1,response.getTasks().size());
ShortTaskStatus taskStatus=response.getTasks().get(0);
Assert.assertEquals(hostname1,taskStatus.getHostName());
Stage stage=actionDB.getAllStages(response.getRequestId()).get(0);
Assert.assertNotNull(stage);
Assert.assertEquals(-1L,stage.getClusterId());
List storedTasks=actionDB.getRequestTasks(response.getRequestId());
Assert.assertEquals(1,storedTasks.size());
HostRoleCommand task=storedTasks.get(0);
Assert.assertEquals(RoleCommand.ACTIONEXECUTE,task.getRoleCommand());
Assert.assertEquals("a1",task.getRole().name());
Assert.assertEquals(hostname1,task.getHostName());
ExecutionCommand cmd=task.getExecutionCommandWrapper().getExecutionCommand();
Type type=new TypeToken>(){
}
.getType();
Map commandParamsStage=StageUtils.getGson().fromJson(stage.getCommandParamsStage(),type);
Assert.assertTrue(commandParamsStage.containsKey("some_custom_param"));
Assert.assertEquals(null,cmd.getServiceName());
Assert.assertEquals(null,cmd.getComponentName());
Assert.assertTrue(cmd.getLocalComponents().isEmpty());
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
hosts=Arrays.asList(hostname1,hostname2);
resourceFilter=new RequestResourceFilter(null,null,hosts);
resourceFilters=new ArrayList();
resourceFilters.add(resourceFilter);
actionRequest=new ExecuteActionRequest(null,null,"a1",resourceFilters,null,requestParams,false);
response=controller.createAction(actionRequest,requestProperties);
assertEquals(2,response.getTasks().size());
boolean host1Found=false;
boolean host2Found=false;
for ( ShortTaskStatus sts : response.getTasks()) {
if (sts.getHostName().equals(hostname1)) {
host1Found=true;
}
else if (sts.getHostName().equals(hostname2)) {
host2Found=true;
}
}
Assert.assertTrue(host1Found);
Assert.assertTrue(host2Found);
stage=actionDB.getAllStages(response.getRequestId()).get(0);
Assert.assertNotNull(stage);
Assert.assertEquals(-1L,stage.getClusterId());
storedTasks=actionDB.getRequestTasks(response.getRequestId());
Assert.assertEquals(2,storedTasks.size());
task=storedTasks.get(0);
Assert.assertEquals(RoleCommand.ACTIONEXECUTE,task.getRoleCommand());
Assert.assertEquals("a1",task.getRole().name());
Assert.assertEquals(hostname1,task.getHostName());
cmd=task.getExecutionCommandWrapper().getExecutionCommand();
commandParamsStage=StageUtils.getGson().fromJson(stage.getCommandParamsStage(),type);
Assert.assertTrue(commandParamsStage.containsKey("some_custom_param"));
Assert.assertEquals(null,cmd.getServiceName());
Assert.assertEquals(null,cmd.getComponentName());
Assert.assertTrue(cmd.getLocalComponents().isEmpty());
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier IgnoredMethod HybridVerifier configs=new HashMap();
configs.put("a","b");
configs.put("command_retry_enabled","true");
configs.put("command_retry_max_time_in_sec","5");
configs.put("commands_to_retry","INSTALL");
ConfigurationRequest cr1;
cr1=new ConfigurationRequest(clusterName,"cluster-env","version1",configs,null);
ClusterRequest crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
Map mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
ServiceComponentHostRequest schr=new ServiceComponentHostRequest(clusterName,"HDFS","DATANODE",host2,"INSTALLED");
Map requestProps=new HashMap();
requestProps.put("phase","INITIAL_INSTALL");
RequestStatusResponse rsr=updateHostComponents(Collections.singleton(schr),requestProps,false);
List stages=actionDB.getAllStages(rsr.getRequestId());
Assert.assertEquals(1,stages.size());
Stage stage=stages.iterator().next();
List execWrappers=stage.getExecutionCommands(host2);
Assert.assertEquals(1,execWrappers.size());
ExecutionCommandWrapper execWrapper=execWrappers.iterator().next();
ExecutionCommand ec=execWrapper.getExecutionCommand();
Map> configurations=ec.getConfigurations();
assertNotNull(configurations);
assertEquals(1,configurations.size());
assertTrue(configurations.containsKey("cluster-env"));
assertTrue(ec.getCommandParams().containsKey("max_duration_for_retries"));
assertEquals("5",ec.getCommandParams().get("max_duration_for_retries"));
assertTrue(ec.getCommandParams().containsKey("command_retry_enabled"));
assertEquals("true",ec.getCommandParams().get("command_retry_enabled"));
for ( ServiceComponentHost sch : clusters.getCluster(clusterName).getServiceComponentHosts(host2)) {
sch.setState(State.INSTALLED);
}
schr=new ServiceComponentHostRequest(clusterName,"HDFS","DATANODE",host2,"STARTED");
rsr=updateHostComponents(Collections.singleton(schr),requestProps,false);
stages=actionDB.getAllStages(rsr.getRequestId());
Assert.assertEquals(1,stages.size());
stage=stages.iterator().next();
execWrappers=stage.getExecutionCommands(host2);
Assert.assertEquals(1,execWrappers.size());
execWrapper=execWrappers.iterator().next();
ec=execWrapper.getExecutionCommand();
configurations=ec.getConfigurations();
assertNotNull(configurations);
assertEquals(1,configurations.size());
assertTrue(configurations.containsKey("cluster-env"));
assertTrue(ec.getCommandParams().containsKey("max_duration_for_retries"));
assertEquals("5",ec.getCommandParams().get("max_duration_for_retries"));
assertTrue(ec.getCommandParams().containsKey("command_retry_enabled"));
assertEquals("false",ec.getCommandParams().get("command_retry_enabled"));
configs.put("command_retry_enabled","true");
configs.put("command_retry_max_time_in_sec","12");
configs.put("commands_to_retry","START");
cr1=new ConfigurationRequest(clusterName,"cluster-env","version2",configs,null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
requestProps.put("phase","INITIAL_START");
schr=new ServiceComponentHostRequest(clusterName,"HDFS","DATANODE",host2,"STARTED");
rsr=updateHostComponents(Collections.singleton(schr),requestProps,false);
stages=actionDB.getAllStages(rsr.getRequestId());
Assert.assertEquals(1,stages.size());
stage=stages.iterator().next();
execWrappers=stage.getExecutionCommands(host2);
Assert.assertEquals(1,execWrappers.size());
execWrapper=execWrappers.iterator().next();
ec=execWrapper.getExecutionCommand();
configurations=ec.getConfigurations();
assertNotNull(configurations);
assertEquals(1,configurations.size());
assertTrue(configurations.containsKey("cluster-env"));
assertTrue(ec.getCommandParams().containsKey("max_duration_for_retries"));
assertEquals("12",ec.getCommandParams().get("max_duration_for_retries"));
assertTrue(ec.getCommandParams().containsKey("command_retry_enabled"));
assertEquals("true",ec.getCommandParams().get("command_retry_enabled"));
configs.put("command_retry_enabled","asdf");
configs.put("command_retry_max_time_in_sec","-5");
configs.put("commands_to_retry2","START");
cr1=new ConfigurationRequest(clusterName,"cluster-env","version3",configs,null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
requestProps.put("phase","INITIAL_START");
schr=new ServiceComponentHostRequest(clusterName,"HDFS","DATANODE",host2,"STARTED");
rsr=updateHostComponents(Collections.singleton(schr),requestProps,false);
stages=actionDB.getAllStages(rsr.getRequestId());
Assert.assertEquals(1,stages.size());
stage=stages.iterator().next();
execWrappers=stage.getExecutionCommands(host2);
Assert.assertEquals(1,execWrappers.size());
execWrapper=execWrappers.iterator().next();
ec=execWrapper.getExecutionCommand();
configurations=ec.getConfigurations();
assertNotNull(configurations);
assertEquals(1,configurations.size());
assertTrue(configurations.containsKey("cluster-env"));
assertTrue(ec.getCommandParams().containsKey("max_duration_for_retries"));
assertEquals("0",ec.getCommandParams().get("max_duration_for_retries"));
assertTrue(ec.getCommandParams().containsKey("command_retry_enabled"));
assertEquals("false",ec.getCommandParams().get("command_retry_enabled"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createServiceComponentHost(clusterName,null,componentName1,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName1).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName3).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName3).getServiceComponentHost(host2));
ServiceRequest r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
Set requests=new HashSet();
requests.add(r);
ServiceResourceProviderTest.updateServices(controller,requests,mapRequestProps,true,false);
Assert.assertEquals(State.INSTALLED,clusters.getCluster(clusterName).getService(serviceName).getDesiredState());
for ( ServiceComponentHost sch : clusters.getCluster(clusterName).getServiceComponentHosts(host1)) {
sch.setState(State.INSTALLED);
}
for ( ServiceComponentHost sch : clusters.getCluster(clusterName).getServiceComponentHosts(host2)) {
sch.setState(State.UNKNOWN);
}
ServiceComponentHostRequest schr=new ServiceComponentHostRequest(clusterName,"HDFS","DATANODE",host2,"INSTALLED");
Map requestProps=new HashMap();
requestProps.put("datanode","dn_value");
requestProps.put("namenode","nn_value");
RequestStatusResponse rsr=updateHostComponents(Collections.singleton(schr),requestProps,false);
List stages=actionDB.getAllStages(rsr.getRequestId());
Assert.assertEquals(1,stages.size());
Stage stage=stages.iterator().next();
List execWrappers=stage.getExecutionCommands(host2);
Assert.assertEquals(1,execWrappers.size());
ExecutionCommandWrapper execWrapper=execWrappers.iterator().next();
Assert.assertTrue(execWrapper.getExecutionCommand().getCommandParams().containsKey("datanode"));
Assert.assertFalse(execWrapper.getExecutionCommand().getCommandParams().containsKey("namendode"));
for ( ServiceComponentHost sch : clusters.getCluster(clusterName).getServiceComponentHosts(host2)) {
Assert.assertEquals(State.UNKNOWN,sch.getState());
}
}
APIUtilityVerifier InternalCallVerifier ConditionMatcher hostParams=new HashMap();
Map packages=new HashMap();
String[] packageNames={"hive","mysql-connector-java","mysql","mysql-server","mysql-client"};
for ( String packageName : packageNames) {
ServiceOsSpecific.Package pkg=new ServiceOsSpecific.Package();
pkg.setName(packageName);
packages.put(packageName,pkg);
}
List rhel5Packages=controller.getPackagesForServiceHost(service,hostParams,"redhat5");
List expectedRhel5=Arrays.asList(packages.get("hive"),packages.get("mysql-connector-java"),packages.get("mysql"),packages.get("mysql-server"));
List sles11Packages=controller.getPackagesForServiceHost(service,hostParams,"suse11");
List expectedSles11=Arrays.asList(packages.get("hive"),packages.get("mysql-connector-java"),packages.get("mysql"),packages.get("mysql-client"));
assertThat(rhel5Packages,is(expectedRhel5));
assertThat(sles11Packages,is(expectedSles11));
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier set1=new HashSet();
ServiceComponentHostRequest r1=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host1,State.INIT.toString());
ServiceComponentHostRequest r2=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host1,State.INIT.toString());
ServiceComponentHostRequest r3=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host2,State.INIT.toString());
ServiceComponentHostRequest r4=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host2,State.INIT.toString());
ServiceComponentHostRequest r5=new ServiceComponentHostRequest(clusterName,serviceName1,componentName3,host1,State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
set1.add(r4);
set1.add(r5);
controller.createHostComponents(set1);
Cluster c1=clusters.getCluster(clusterName);
Service s1=c1.getService(serviceName1);
ServiceComponent sc1=s1.getServiceComponent(componentName1);
ServiceComponent sc2=s1.getServiceComponent(componentName2);
ServiceComponent sc3=s1.getServiceComponent(componentName3);
ServiceComponentHost sch1=sc1.getServiceComponentHost(host1);
ServiceComponentHost sch2=sc2.getServiceComponentHost(host1);
ServiceComponentHost sch3=sc1.getServiceComponentHost(host2);
ServiceComponentHost sch4=sc2.getServiceComponentHost(host2);
ServiceComponentHost sch5=sc3.getServiceComponentHost(host1);
s1.setDesiredState(State.INIT);
sc1.setDesiredState(State.INIT);
sc2.setDesiredState(State.INIT);
sc3.setDesiredState(State.INIT);
sch1.setDesiredState(State.INIT);
sch2.setDesiredState(State.INIT);
sch3.setDesiredState(State.INIT);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.INSTALLED);
sch1.setState(State.INIT);
sch2.setState(State.INSTALL_FAILED);
sch3.setState(State.INIT);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
ServiceComponentHostRequest req1, req2, req3, req4, req5;
Set reqs=new HashSet();
try {
reqs.clear();
req1=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host1,State.INSTALLED.toString());
req2=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host2,State.INSTALLED.toString());
req3=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host1,State.INSTALLED.toString());
req4=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host2,State.INSTALLED.toString());
req5=new ServiceComponentHostRequest(clusterName,serviceName1,componentName3,host1,State.STARTED.toString());
reqs.add(req1);
reqs.add(req2);
reqs.add(req3);
reqs.add(req4);
reqs.add(req5);
updateHostComponents(reqs,Collections.emptyMap(),true);
}
catch ( Exception e) {
fail("Failure for invalid states");
}
reqs.clear();
req1=new ServiceComponentHostRequest(clusterName,null,componentName1,host1,State.INSTALLED.toString());
req2=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host2,State.INSTALLED.toString());
req3=new ServiceComponentHostRequest(clusterName,null,componentName2,host1,State.INSTALLED.toString());
req4=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host2,State.INSTALLED.toString());
req5=new ServiceComponentHostRequest(clusterName,serviceName1,componentName3,host1,State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
reqs.add(req3);
reqs.add(req4);
reqs.add(req5);
RequestStatusResponse trackAction=updateHostComponents(reqs,Collections.emptyMap(),true);
Assert.assertNotNull(trackAction);
long requestId=trackAction.getRequestId();
Assert.assertFalse(actionDB.getAllStages(requestId).isEmpty());
List stages=actionDB.getAllStages(requestId);
for ( Stage stage : stages) {
LOG.debug("Stage dump: " + stage.toString());
}
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.INSTALLED);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
reqs.clear();
req1=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host1,State.INSTALLED.toString());
req2=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host2,State.INSTALLED.toString());
reqs.add(req1);
reqs.add(req2);
trackAction=updateHostComponents(reqs,Collections.emptyMap(),true);
Assert.assertNull(trackAction);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier responses=controller.getRootServices(Collections.singleton(request));
Assert.assertEquals(RootServiceResponseFactory.Services.values().length,responses.size());
RootServiceRequest requestWithParams=new RootServiceRequest(RootServiceResponseFactory.Services.AMBARI.toString());
Set responsesWithParams=controller.getRootServices(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( RootServiceResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getServiceName(),RootServiceResponseFactory.Services.AMBARI.toString());
}
RootServiceRequest invalidRequest=new RootServiceRequest(NON_EXT_VALUE);
try {
controller.getRootServices(Collections.singleton(invalidRequest));
}
catch ( ObjectNotFoundException e) {
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier setReqs=new HashSet();
setReqs.add(schr);
RequestStatusResponse resp=updateHostComponents(setReqs,Collections.emptyMap(),false);
Assert.assertNotNull(resp);
Assert.assertTrue(resp.getRequestId() > 0);
List stages=actionDB.getAllStages(resp.getRequestId());
HostRoleCommand clientReinstallCmd=null;
for ( Stage stage : stages) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getHostName().equals(host3) && hrc.getRole().toString().equals("HDFS_CLIENT")) {
clientReinstallCmd=hrc;
break;
}
}
}
Assert.assertNotNull(clientReinstallCmd);
}
UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier set1=new HashSet();
try {
set1.clear();
ServiceComponentRequest rInvalid=new ServiceComponentRequest(null,null,null,null);
set1.add(rInvalid);
ComponentResourceProviderTest.createComponents(controller,set1);
fail("Expected failure for invalid requests");
}
catch ( Exception e) {
}
try {
set1.clear();
ServiceComponentRequest rInvalid=new ServiceComponentRequest("c1",null,null,null);
set1.add(rInvalid);
ComponentResourceProviderTest.createComponents(controller,set1);
fail("Expected failure for invalid requests");
}
catch ( Exception e) {
}
try {
set1.clear();
ServiceComponentRequest rInvalid=new ServiceComponentRequest("c1","s1",null,null);
set1.add(rInvalid);
ComponentResourceProviderTest.createComponents(controller,set1);
fail("Expected failure for invalid requests");
}
catch ( Exception e) {
}
try {
set1.clear();
ServiceComponentRequest rInvalid=new ServiceComponentRequest("c1","s1","sc1",null);
set1.add(rInvalid);
ComponentResourceProviderTest.createComponents(controller,set1);
fail("Expected failure for invalid cluster");
}
catch ( ParentObjectNotFoundException e) {
}
clusters.addCluster("c1",new StackId("HDP-0.1"));
clusters.addCluster("c2",new StackId("HDP-0.1"));
try {
set1.clear();
ServiceComponentRequest rInvalid=new ServiceComponentRequest("c1","HDFS","NAMENODE",null);
set1.add(rInvalid);
ComponentResourceProviderTest.createComponents(controller,set1);
fail("Expected failure for invalid service");
}
catch ( ParentObjectNotFoundException e) {
}
Cluster c1=clusters.getCluster("c1");
StackId stackId=new StackId("HDP-0.1");
c1.setDesiredStackVersion(stackId);
helper.getOrCreateRepositoryVersion(stackId,stackId.getStackVersion());
c1.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
Service s1=serviceFactory.createNew(c1,"HDFS");
Service s2=serviceFactory.createNew(c1,"MAPREDUCE");
c1.addService(s1);
c1.addService(s2);
s1.persist();
s2.persist();
set1.clear();
ServiceComponentRequest valid1=new ServiceComponentRequest("c1","HDFS","NAMENODE",null);
ServiceComponentRequest valid2=new ServiceComponentRequest("c1","MAPREDUCE","JOBTRACKER",null);
ServiceComponentRequest valid3=new ServiceComponentRequest("c1","MAPREDUCE","TASKTRACKER",null);
set1.add(valid1);
set1.add(valid2);
set1.add(valid3);
ComponentResourceProviderTest.createComponents(controller,set1);
try {
set1.clear();
ServiceComponentRequest rInvalid1=new ServiceComponentRequest("c1","HDFS","HDFS_CLIENT",null);
ServiceComponentRequest rInvalid2=new ServiceComponentRequest("c1","HDFS","HDFS_CLIENT",null);
set1.add(rInvalid1);
set1.add(rInvalid2);
ComponentResourceProviderTest.createComponents(controller,set1);
fail("Expected failure for dups in requests");
}
catch ( Exception e) {
}
try {
set1.clear();
ServiceComponentRequest rInvalid1=new ServiceComponentRequest("c1","HDFS","HDFS_CLIENT",null);
ServiceComponentRequest rInvalid2=new ServiceComponentRequest("c2","HDFS","HDFS_CLIENT",null);
set1.add(rInvalid1);
set1.add(rInvalid2);
ComponentResourceProviderTest.createComponents(controller,set1);
fail("Expected failure for multiple clusters");
}
catch ( Exception e) {
}
try {
set1.clear();
ServiceComponentRequest rInvalid=new ServiceComponentRequest("c1","HDFS","NAMENODE",null);
set1.add(rInvalid);
ComponentResourceProviderTest.createComponents(controller,set1);
fail("Expected failure for already existing component");
}
catch ( Exception e) {
}
Assert.assertEquals(1,s1.getServiceComponents().size());
Assert.assertNotNull(s1.getServiceComponent("NAMENODE"));
Assert.assertEquals(2,s2.getServiceComponents().size());
Assert.assertNotNull(s2.getServiceComponent("JOBTRACKER"));
Assert.assertNotNull(s2.getServiceComponent("TASKTRACKER"));
}
BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier configs=new HashMap();
configs.put("a","b");
Map configs2=new HashMap();
configs2.put("c","d");
ConfigurationRequest cr1, cr2, cr3;
cr1=new ConfigurationRequest(clusterName,"core-site","version1",configs,null);
cr2=new ConfigurationRequest(clusterName,"hdfs-site","version1",configs,null);
ClusterRequest crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr1));
controller.updateClusters(Collections.singleton(crReq),null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr2));
controller.updateClusters(Collections.singleton(crReq),null);
installService(clusterName,serviceName,false,false);
startService(clusterName,serviceName,false,false);
Cluster c=clusters.getCluster(clusterName);
Service s=c.getService(serviceName);
stopServiceComponentHosts(clusterName,serviceName);
Assert.assertEquals(State.STARTED,s.getDesiredState());
for ( ServiceComponent sc : s.getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INSTALLED,sch.getDesiredState());
}
}
cr3=new ConfigurationRequest(clusterName,"core-site","version122",configs2,null);
crReq=new ClusterRequest(cluster.getClusterId(),clusterName,null,null);
crReq.setDesiredConfig(Collections.singletonList(cr3));
controller.updateClusters(Collections.singleton(crReq),null);
long id=startService(clusterName,serviceName,false,true);
List stages=actionDB.getAllStages(id);
HostRoleCommand clientHrc=null;
for ( Stage stage : stages) {
for ( HostRoleCommand hrc : stage.getOrderedHostRoleCommands()) {
if (hrc.getHostName().equals(host2) && hrc.getRole().toString().equals("HDFS_CLIENT")) {
clientHrc=hrc;
Assert.assertEquals("version122",hrc.getExecutionCommandWrapper().getExecutionCommand().getConfigurationTags().get("core-site").get("tag"));
}
}
}
Assert.assertNotNull(clientHrc);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier responses=controller.getOperatingSystems(Collections.singleton(request));
Assert.assertEquals(OS_CNT,responses.size());
OperatingSystemRequest requestWithParams=new OperatingSystemRequest(STACK_NAME,STACK_VERSION,OS_TYPE);
Set responsesWithParams=controller.getOperatingSystems(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( OperatingSystemResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getOsType(),OS_TYPE);
}
OperatingSystemRequest invalidRequest=new OperatingSystemRequest(STACK_NAME,STACK_VERSION,NON_EXT_VALUE);
try {
controller.getOperatingSystems(Collections.singleton(invalidRequest));
}
catch ( StackAccessException e) {
}
}
InternalCallVerifier NullVerifier (){
{
add("h1");
add("h2");
add("h3");
}
}
,"centos5");
Service hdfs=c1.addService("HDFS");
hdfs.persist();
createServiceComponent("c1","HDFS","NAMENODE",State.INIT);
createServiceComponent("c1","HDFS","DATANODE",State.INIT);
createServiceComponent("c1","HDFS","HDFS_CLIENT",State.INIT);
createServiceComponentHost("c1","HDFS","NAMENODE","h1",State.INIT);
createServiceComponentHost("c1","HDFS","DATANODE","h1",State.INIT);
createServiceComponentHost("c1","HDFS","HDFS_CLIENT","h1",State.INIT);
createServiceComponentHost("c1","HDFS","HDFS_CLIENT","h2",State.INIT);
createServiceComponentHost("c1","HDFS","HDFS_CLIENT","h3",State.INIT);
installService("c1","HDFS",false,false);
clusters.getHost("h3").setMaintenanceState(c1.getClusterId(),MaintenanceState.ON);
Long id=startService("c1","HDFS",false,true);
Assert.assertNotNull(id);
List stages=actionDB.getAllStages(id);
Assert.assertNotNull(stages);
HostRoleCommand hrc1=null;
HostRoleCommand hrc2=null;
HostRoleCommand hrc3=null;
for ( Stage s : stages) {
for ( HostRoleCommand hrc : s.getOrderedHostRoleCommands()) {
if (hrc.getRole().equals(Role.HDFS_CLIENT) && hrc.getHostName().equals("h1")) {
hrc1=hrc;
}
else if (hrc.getRole().equals(Role.HDFS_CLIENT) && hrc.getHostName().equals("h2")) {
hrc2=hrc;
}
else if (hrc.getRole().equals(Role.HDFS_CLIENT) && hrc.getHostName().equals("h3")) {
hrc3=hrc;
}
}
}
Assert.assertNotNull(hrc1);
Assert.assertNotNull(hrc2);
Assert.assertNull(hrc3);
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier commands=actionDB.getRequestTasks(requestId);
Assert.assertEquals(3,commands.size());
int commandCount=0;
for ( HostRoleCommand command : commands) {
if (command.getRoleCommand() == RoleCommand.START) {
Assert.assertTrue(command.getHostName().equals("h1") || command.getHostName().equals("h2"));
commandCount++;
}
}
Assert.assertEquals("Expect only two task.",2,commandCount);
stopService(clusterName,serviceName,false,false);
clusters.getHost("h1").setState(HostState.HEARTBEAT_LOST);
clusters.getHost("h2").setState(HostState.HEARTBEAT_LOST);
clusters.getHost("h3").setState(HostState.HEALTHY);
requestId=startService(clusterName,serviceName,true,false);
commands=actionDB.getRequestTasks(requestId);
commandCount=0;
for ( HostRoleCommand command : commands) {
if (command.getRoleCommand() == RoleCommand.START) {
Assert.assertTrue(command.getHostName().equals("h3"));
commandCount++;
}
}
Assert.assertEquals("Expect only one task.",1,commandCount);
stopService(clusterName,serviceName,false,false);
clusters.getHost("h1").setState(HostState.HEALTHY);
clusters.getHost("h2").setState(HostState.HEALTHY);
clusters.getHost("h3").setState(HostState.HEALTHY);
requestId=startService(clusterName,serviceName,true,false);
commands=actionDB.getRequestTasks(requestId);
commandCount=0;
for ( HostRoleCommand command : commands) {
if (command.getRoleCommand() == RoleCommand.START) {
Assert.assertTrue(command.getHostName().equals("h3") || command.getHostName().equals("h2") || command.getHostName().equals("h1"));
commandCount++;
}
}
Assert.assertEquals("Expect all three task.",3,commandCount);
clusters.getHost("h2").setState(HostState.HEARTBEAT_LOST);
requestId=stopService(clusterName,serviceName,false,false);
commands=actionDB.getRequestTasks(requestId);
Assert.assertEquals(2,commands.size());
commandCount=0;
for ( HostRoleCommand command : commands) {
if (command.getRoleCommand() == RoleCommand.STOP) {
Assert.assertTrue(command.getHostName().equals("h3") || command.getHostName().equals("h1"));
commandCount++;
}
}
Assert.assertEquals("Expect only two task.",2,commandCount);
Cluster cluster=clusters.getCluster(clusterName);
Service s=cluster.getService(serviceName);
ServiceComponent sc3=s.getServiceComponent(componentName2);
for ( ServiceComponentHost sch : sc3.getServiceComponentHosts().values()) {
if (sch.getHostName().equals("h3")) {
sch.setState(State.INSTALL_FAILED);
}
}
clusters.getHost("h3").setState(HostState.HEARTBEAT_LOST);
clusters.getHost("h2").setState(HostState.HEALTHY);
requestId=installService(clusterName,serviceName,false,false);
Assert.assertEquals(-1,requestId);
clusters.getHost("h3").setState(HostState.HEALTHY);
requestId=installService(clusterName,serviceName,false,false);
commands=actionDB.getRequestTasks(requestId);
Assert.assertEquals(1,commands.size());
commandCount=0;
for ( HostRoleCommand command : commands) {
if (command.getRoleCommand() == RoleCommand.INSTALL) {
Assert.assertTrue(command.getHostName().equals("h3"));
commandCount++;
}
}
Assert.assertEquals("Expect only one task.",1,commandCount);
}
APIUtilityVerifier BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier requestProperties=new HashMap();
requestProperties.put("context","Called from a test");
Cluster cluster=clusters.getCluster(clusterName);
Service service=cluster.getService(serviceName);
Map hosts=clusters.getHostsForCluster(clusterName);
MaintenanceStateHelper maintenanceStateHelper=MaintenanceStateHelperTest.getMaintenanceStateHelperInstance(clusters);
ServiceRequest sr=new ServiceRequest(clusterName,serviceName,null);
sr.setMaintenanceState(MaintenanceState.ON.name());
ServiceResourceProviderTest.updateServices(controller,Collections.singleton(sr),requestProperties,false,false,maintenanceStateHelper);
Assert.assertEquals(MaintenanceState.ON,service.getMaintenanceState());
for ( ServiceComponent sc : service.getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(MaintenanceState.IMPLIED_FROM_SERVICE,controller.getEffectiveMaintenanceState(sch));
Assert.assertEquals(MaintenanceState.OFF,sch.getMaintenanceState());
}
}
sr.setMaintenanceState(MaintenanceState.OFF.name());
ServiceResourceProviderTest.updateServices(controller,Collections.singleton(sr),requestProperties,false,false,maintenanceStateHelper);
Assert.assertEquals(MaintenanceState.OFF,service.getMaintenanceState());
for ( ServiceComponent sc : service.getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(MaintenanceState.OFF,controller.getEffectiveMaintenanceState(sch));
Assert.assertEquals(MaintenanceState.OFF,sch.getMaintenanceState());
}
}
HostRequest hr=new HostRequest(host1,clusterName,requestProperties);
hr.setMaintenanceState(MaintenanceState.ON.name());
HostResourceProviderTest.updateHosts(controller,Collections.singleton(hr));
Host host=hosts.get(host1);
Assert.assertEquals(MaintenanceState.ON,host.getMaintenanceState(cluster.getClusterId()));
for ( ServiceComponent sc : service.getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
MaintenanceState implied=controller.getEffectiveMaintenanceState(sch);
if (sch.getHostName().equals(host1)) {
Assert.assertEquals(MaintenanceState.IMPLIED_FROM_HOST,implied);
}
else {
Assert.assertEquals(MaintenanceState.OFF,implied);
}
Assert.assertEquals(MaintenanceState.OFF,sch.getMaintenanceState());
}
}
hr.setMaintenanceState(MaintenanceState.OFF.name());
HostResourceProviderTest.updateHosts(controller,Collections.singleton(hr));
host=hosts.get(host1);
Assert.assertEquals(MaintenanceState.OFF,host.getMaintenanceState(cluster.getClusterId()));
for ( ServiceComponent sc : service.getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(MaintenanceState.OFF,controller.getEffectiveMaintenanceState(sch));
Assert.assertEquals(MaintenanceState.OFF,sch.getMaintenanceState());
}
}
HostRequest hr1=new HostRequest(host1,clusterName,requestProperties);
hr1.setMaintenanceState(MaintenanceState.ON.name());
HostRequest hr2=new HostRequest(host2,clusterName,requestProperties);
hr2.setMaintenanceState(MaintenanceState.ON.name());
Set set=new HashSet();
set.add(hr1);
set.add(hr2);
HostResourceProviderTest.updateHosts(controller,set);
host=hosts.get(host1);
Assert.assertEquals(MaintenanceState.ON,host.getMaintenanceState(cluster.getClusterId()));
host=hosts.get(host2);
Assert.assertEquals(MaintenanceState.ON,host.getMaintenanceState(cluster.getClusterId()));
hr1=new HostRequest(host1,clusterName,requestProperties);
hr1.setMaintenanceState(MaintenanceState.OFF.name());
hr2=new HostRequest(host2,clusterName,requestProperties);
hr2.setMaintenanceState(MaintenanceState.OFF.name());
set=new HashSet();
set.add(hr1);
set.add(hr2);
HostResourceProviderTest.updateHosts(controller,set);
host=hosts.get(host1);
Assert.assertEquals(MaintenanceState.OFF,host.getMaintenanceState(cluster.getClusterId()));
host=hosts.get(host2);
Assert.assertEquals(MaintenanceState.OFF,host.getMaintenanceState(cluster.getClusterId()));
ServiceComponentHost targetSch=service.getServiceComponent(componentName2).getServiceComponentHosts().get(host2);
Assert.assertNotNull(targetSch);
targetSch.setMaintenanceState(MaintenanceState.ON);
Assert.assertEquals(MaintenanceState.ON,controller.getEffectiveMaintenanceState(targetSch));
service.setMaintenanceState(MaintenanceState.ON);
Assert.assertEquals(MaintenanceState.ON,controller.getEffectiveMaintenanceState(targetSch));
targetSch.setMaintenanceState(MaintenanceState.OFF);
Assert.assertEquals(MaintenanceState.IMPLIED_FROM_SERVICE,controller.getEffectiveMaintenanceState(targetSch));
service.setMaintenanceState(MaintenanceState.OFF);
Assert.assertEquals(MaintenanceState.OFF,controller.getEffectiveMaintenanceState(targetSch));
host=hosts.get(host2);
host.setMaintenanceState(cluster.getClusterId(),MaintenanceState.ON);
Assert.assertEquals(MaintenanceState.IMPLIED_FROM_HOST,controller.getEffectiveMaintenanceState(targetSch));
targetSch.setMaintenanceState(MaintenanceState.ON);
Assert.assertEquals(MaintenanceState.ON,controller.getEffectiveMaintenanceState(targetSch));
for ( ServiceComponent sc : service.getServiceComponents().values()) {
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(State.INIT,sch.getState());
}
}
long id1=installService(clusterName,serviceName,false,false,maintenanceStateHelper,null);
List hdfsCmds=actionDB.getRequestTasks(id1);
Assert.assertNotNull(hdfsCmds);
HostRoleCommand datanodeCmd=null;
for ( HostRoleCommand cmd : hdfsCmds) {
if (cmd.getRole().equals(Role.DATANODE)) {
datanodeCmd=cmd;
}
}
Assert.assertNotNull(datanodeCmd);
for ( ServiceComponent sc : service.getServiceComponents().values()) {
if (!sc.getName().equals(componentName2)) {
continue;
}
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
Assert.assertEquals(sch == targetSch ? State.INIT : State.INSTALLED,sch.getState());
}
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > config=new HashMap>();
config.put("type1",new HashMap());
config.put("type3",new HashMap());
config.get("type3").put("name1","neverchange");
configHelper.applyCustomConfig(config,"type1","name1","value11",false);
Assert.assertEquals("value11",config.get("type1").get("name1"));
config.put("type1",new HashMap());
configHelper.applyCustomConfig(config,"type1","name1","value12",false);
Assert.assertEquals("value12",config.get("type1").get("name1"));
configHelper.applyCustomConfig(config,"type2","name2","value21",false);
Assert.assertEquals("value21",config.get("type2").get("name2"));
configHelper.applyCustomConfig(config,"type2","name2","",true);
Assert.assertEquals("",config.get("type2").get("DELETED_name2"));
Assert.assertEquals("neverchange",config.get("type3").get("name1"));
Map persistedClusterConfig=new HashMap();
persistedClusterConfig.put("name1","value11");
persistedClusterConfig.put("name3","value31");
persistedClusterConfig.put("name4","value41");
Map override=new HashMap();
override.put("name1","value12");
override.put("name2","value21");
override.put("DELETED_name3","value31");
Map mergedConfig=configHelper.getMergedConfig(persistedClusterConfig,override);
Assert.assertEquals(3,mergedConfig.size());
Assert.assertFalse(mergedConfig.containsKey("name3"));
Assert.assertEquals("value12",mergedConfig.get("name1"));
Assert.assertEquals("value21",mergedConfig.get("name2"));
Assert.assertEquals("value41",mergedConfig.get("name4"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
add("h1");
add("h2");
add("h3");
}
}
,"centos6");
Cluster cluster=clusters.getCluster("c1");
cluster.setDesiredStackVersion(new StackId("HDP-2.0.6"));
cluster.setCurrentStackVersion(new StackId("HDP-2.0.6"));
ConfigFactory cf=injector.getInstance(ConfigFactory.class);
Config config1=cf.createNew(cluster,"global",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config1.setTag("version1");
Config config2=cf.createNew(cluster,"core-site",new HashMap(){
{
put("key1","value1");
}
}
,new HashMap>());
config2.setTag("version1");
Config config3=cf.createNew(cluster,"yarn-site",new HashMap(){
{
put("test.password","supersecret");
}
}
,new HashMap>());
config3.setTag("version1");
cluster.addConfig(config1);
cluster.addConfig(config2);
cluster.addConfig(config3);
Service hdfs=cluster.addService("HDFS");
hdfs.persist();
Service mapred=cluster.addService("YARN");
mapred.persist();
hdfs.addServiceComponent(Role.HDFS_CLIENT.name()).persist();
hdfs.addServiceComponent(Role.NAMENODE.name()).persist();
hdfs.addServiceComponent(Role.DATANODE.name()).persist();
mapred.addServiceComponent(Role.RESOURCEMANAGER.name()).persist();
hdfs.getServiceComponent(Role.HDFS_CLIENT.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.NAMENODE.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost("h1").persist();
hdfs.getServiceComponent(Role.DATANODE.name()).addServiceComponentHost("h2").persist();
ActionDefinition a1=new ActionDefinition("a1",ActionType.SYSTEM,"test,[optional1]","","","Does file exist",TargetHostType.SPECIFIC,Short.valueOf("100"));
controller.getAmbariMetaInfo().addActionDefinition(a1);
controller.getAmbariMetaInfo().addActionDefinition(new ActionDefinition("a2",ActionType.SYSTEM,"","HDFS","DATANODE","Does file exist",TargetHostType.ALL,Short.valueOf("1000")));
Map params=new HashMap(){
{
put("test","test");
put("pwd","SECRET:yarn-site:1:test.password");
}
}
;
Map requestProperties=new HashMap();
requestProperties.put(REQUEST_CONTEXT_PROPERTY,"Called from a test");
requestProperties.put("datanode","abc");
ArrayList hosts=new ArrayList(){
{
add("h1");
}
}
;
RequestResourceFilter resourceFilter=new RequestResourceFilter("HDFS","DATANODE",hosts);
List resourceFilters=new ArrayList();
resourceFilters.add(resourceFilter);
ExecuteActionRequest actionRequest=new ExecuteActionRequest("c1",null,"a1",resourceFilters,null,params,false);
RequestStatusResponse response=controller.createAction(actionRequest,requestProperties);
assertEquals(1,response.getTasks().size());
ShortTaskStatus taskStatus=response.getTasks().get(0);
Assert.assertEquals("h1",taskStatus.getHostName());
List storedTasks=actionDB.getRequestTasks(response.getRequestId());
Stage stage=actionDB.getAllStages(response.getRequestId()).get(0);
Assert.assertNotNull(stage);
Assert.assertEquals(1,storedTasks.size());
HostRoleCommand task=storedTasks.get(0);
Assert.assertEquals(RoleCommand.ACTIONEXECUTE,task.getRoleCommand());
Assert.assertEquals("a1",task.getRole().name());
Assert.assertEquals("h1",task.getHostName());
ExecutionCommand cmd=task.getExecutionCommandWrapper().getExecutionCommand();
Assert.assertEquals("h1",cmd.getHostname());
Assert.assertFalse(cmd.getLocalComponents().isEmpty());
Assert.assertTrue(cmd.getLocalComponents().contains(Role.DATANODE.name()));
Assert.assertTrue(cmd.getLocalComponents().contains(Role.NAMENODE.name()));
Assert.assertTrue(cmd.getLocalComponents().contains(Role.HDFS_CLIENT.name()));
Assert.assertFalse(cmd.getLocalComponents().contains(Role.RESOURCEMANAGER.name()));
Type type=new TypeToken>(){
}
.getType();
Map hostParametersStage=StageUtils.getGson().fromJson(stage.getHostParamsStage(),type);
Map commandParametersStage=StageUtils.getGson().fromJson(stage.getCommandParamsStage(),type);
Assert.assertTrue(commandParametersStage.containsKey("test"));
Assert.assertTrue(commandParametersStage.containsKey("pwd"));
Assert.assertEquals(commandParametersStage.get("pwd"),"supersecret");
Assert.assertEquals("HDFS",cmd.getServiceName());
Assert.assertEquals("DATANODE",cmd.getComponentName());
Assert.assertNotNull(hostParametersStage.get("jdk_location"));
Assert.assertEquals("900",cmd.getCommandParams().get("command_timeout"));
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
a1.setDefaultTimeout((short)1800);
actionRequest=new ExecuteActionRequest("c1",null,"a1",resourceFilters,null,params,false);
response=controller.createAction(actionRequest,requestProperties);
List storedTasks1=actionDB.getRequestTasks(response.getRequestId());
cmd=storedTasks1.get(0).getExecutionCommandWrapper().getExecutionCommand();
Assert.assertEquals("1800",cmd.getCommandParams().get("command_timeout"));
resourceFilters.clear();
resourceFilter=new RequestResourceFilter("","",null);
resourceFilters.add(resourceFilter);
actionRequest=new ExecuteActionRequest("c1",null,"a2",resourceFilters,null,params,false);
response=controller.createAction(actionRequest,requestProperties);
assertEquals(2,response.getTasks().size());
final List storedTasks2=actionDB.getRequestTasks(response.getRequestId());
task=storedTasks2.get(1);
Assert.assertEquals(RoleCommand.ACTIONEXECUTE,task.getRoleCommand());
Assert.assertEquals("a2",task.getRole().name());
HashSet expectedHosts=new HashSet(){
{
add("h2");
add("h1");
}
}
;
HashSet actualHosts=new HashSet(){
{
add(storedTasks2.get(1).getHostName());
add(storedTasks2.get(0).getHostName());
}
}
;
Assert.assertEquals(expectedHosts,actualHosts);
cmd=task.getExecutionCommandWrapper().getExecutionCommand();
commandParametersStage=StageUtils.getGson().fromJson(stage.getCommandParamsStage(),type);
Assert.assertTrue(commandParametersStage.containsKey("test"));
Assert.assertTrue(commandParametersStage.containsKey("pwd"));
Assert.assertEquals(commandParametersStage.get("pwd"),"supersecret");
Assert.assertEquals("HDFS",cmd.getServiceName());
Assert.assertEquals("DATANODE",cmd.getComponentName());
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
Assert.assertEquals("h2",cmd.getHostname());
Assert.assertFalse(cmd.getLocalComponents().isEmpty());
Assert.assertTrue(cmd.getLocalComponents().contains(Role.DATANODE.name()));
Assert.assertFalse(cmd.getLocalComponents().contains(Role.NAMENODE.name()));
Assert.assertFalse(cmd.getLocalComponents().contains(Role.HDFS_CLIENT.name()));
Assert.assertFalse(cmd.getLocalComponents().contains(Role.RESOURCEMANAGER.name()));
hosts=new ArrayList(){
{
add("h3");
}
}
;
resourceFilters.clear();
resourceFilter=new RequestResourceFilter("","",hosts);
resourceFilters.add(resourceFilter);
actionRequest=new ExecuteActionRequest("c1",null,"a1",resourceFilters,null,params,false);
response=controller.createAction(actionRequest,requestProperties);
assertEquals(1,response.getTasks().size());
taskStatus=response.getTasks().get(0);
Assert.assertEquals("h3",taskStatus.getHostName());
Assert.assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY),response.getRequestContext());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier responses=controller.getRootServiceComponents(Collections.singleton(request));
Assert.assertEquals(RootServiceResponseFactory.Services.AMBARI.getComponents().length,responses.size());
RootServiceComponentRequest requestWithParams=new RootServiceComponentRequest(RootServiceResponseFactory.Services.AMBARI.toString(),RootServiceResponseFactory.Services.AMBARI.getComponents()[0].toString());
Set responsesWithParams=controller.getRootServiceComponents(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( RootServiceComponentResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getComponentName(),RootServiceResponseFactory.Services.AMBARI.getComponents()[0].toString());
}
RootServiceComponentRequest invalidRequest=new RootServiceComponentRequest(NON_EXT_VALUE,NON_EXT_VALUE);
try {
controller.getRootServiceComponents(Collections.singleton(invalidRequest));
}
catch ( ObjectNotFoundException e) {
}
}
InternalCallVerifier NullVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createServiceComponent(clusterName,serviceName,componentName1,State.INIT);
createServiceComponent(clusterName,serviceName,componentName2,State.INIT);
createServiceComponent(clusterName,serviceName,componentName3,State.INIT);
String host1="h1";
String host2="h2";
addHostToCluster(host1,clusterName);
addHostToCluster(host2,clusterName);
createServiceComponentHost(clusterName,null,componentName1,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName2,host2,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host1,null);
createServiceComponentHost(clusterName,serviceName,componentName3,host2,null);
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName1).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName3).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName3).getServiceComponentHost(host2));
Map configs=new HashMap();
configs.put("a","b");
Map> configAttributes=new HashMap>();
configAttributes.put("final",new HashMap());
configAttributes.get("final").put("a","true");
ConfigurationRequest cr1, cr2, cr3, cr4, cr5, cr6, cr7, cr8;
cr1=new ConfigurationRequest(clusterName,"typeA","v1",configs,configAttributes);
cr2=new ConfigurationRequest(clusterName,"typeB","v1",configs,configAttributes);
cr3=new ConfigurationRequest(clusterName,"typeC","v1",configs,configAttributes);
cr4=new ConfigurationRequest(clusterName,"typeD","v1",configs,configAttributes);
cr5=new ConfigurationRequest(clusterName,"typeA","v2",configs,configAttributes);
cr6=new ConfigurationRequest(clusterName,"typeB","v2",configs,configAttributes);
cr7=new ConfigurationRequest(clusterName,"typeC","v2",configs,configAttributes);
cr8=new ConfigurationRequest(clusterName,"typeE","v1",configs,configAttributes);
controller.createConfiguration(cr1);
controller.createConfiguration(cr2);
controller.createConfiguration(cr3);
controller.createConfiguration(cr4);
controller.createConfiguration(cr5);
controller.createConfiguration(cr6);
controller.createConfiguration(cr7);
controller.createConfiguration(cr8);
Cluster cluster=clusters.getCluster(clusterName);
Service s=cluster.getService(serviceName);
ServiceComponent sc1=s.getServiceComponent(componentName1);
ServiceComponent sc2=s.getServiceComponent(componentName2);
ServiceComponentHost sch1=sc1.getServiceComponentHost(host1);
Set schReqs=new HashSet();
Set scReqs=new HashSet();
Set sReqs=new HashSet();
Map configVersions=new HashMap();
configVersions.clear();
configVersions.put("typeA","v1");
configVersions.put("typeB","v1");
configVersions.put("typeC","v1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,null));
Assert.assertNull(updateHostComponents(schReqs,Collections.emptyMap(),true));
configVersions.clear();
configVersions.put("typeC","v1");
configVersions.put("typeD","v1");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName,serviceName,componentName2,null));
Assert.assertNull(ComponentResourceProviderTest.updateComponents(controller,scReqs,Collections.emptyMap(),true));
configVersions.clear();
configVersions.put("typeA","v2");
configVersions.put("typeC","v2");
configVersions.put("typeE","v1");
sReqs.clear();
sReqs.add(new ServiceRequest(clusterName,serviceName,null));
Assert.assertNull(ServiceResourceProviderTest.updateServices(controller,sReqs,mapRequestProps,true,false));
configVersions.clear();
configVersions.put("typeA","v1");
configVersions.put("typeB","v1");
configVersions.put("typeC","v1");
schReqs.clear();
schReqs.add(new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,null));
Assert.assertNull(updateHostComponents(schReqs,Collections.emptyMap(),true));
configVersions.clear();
configVersions.put("typeC","v2");
configVersions.put("typeD","v1");
scReqs.clear();
scReqs.add(new ServiceComponentRequest(clusterName,serviceName,componentName1,null));
Assert.assertNull(ComponentResourceProviderTest.updateComponents(controller,scReqs,Collections.emptyMap(),true));
}
APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
createServiceComponent(clusterName,serviceName1,componentName1,State.INIT);
createServiceComponent(clusterName,serviceName1,componentName2,State.INIT);
createServiceComponent(clusterName,serviceName2,componentName3,State.INIT);
createServiceComponent(clusterName,serviceName1,componentName4,State.INIT);
String host1="h1";
String host2="h2";
addHostToCluster(host1,clusterName);
addHostToCluster(host2,clusterName);
Set set1=new HashSet();
ServiceComponentHostRequest r1=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host1,State.INIT.toString());
ServiceComponentHostRequest r2=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host1,State.INIT.toString());
ServiceComponentHostRequest r3=new ServiceComponentHostRequest(clusterName,serviceName1,componentName1,host2,State.INIT.toString());
ServiceComponentHostRequest r4=new ServiceComponentHostRequest(clusterName,serviceName1,componentName2,host2,State.INIT.toString());
ServiceComponentHostRequest r5=new ServiceComponentHostRequest(clusterName,serviceName2,componentName3,host1,State.INIT.toString());
ServiceComponentHostRequest r6=new ServiceComponentHostRequest(clusterName,serviceName1,componentName4,host2,State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
set1.add(r4);
set1.add(r5);
set1.add(r6);
controller.createHostComponents(set1);
Cluster c1=clusters.getCluster(clusterName);
Service s1=c1.getService(serviceName1);
Service s2=c1.getService(serviceName2);
ServiceComponent sc1=s1.getServiceComponent(componentName1);
ServiceComponent sc2=s1.getServiceComponent(componentName2);
ServiceComponent sc3=s2.getServiceComponent(componentName3);
ServiceComponent sc4=s1.getServiceComponent(componentName4);
ServiceComponentHost sch1=sc1.getServiceComponentHost(host1);
ServiceComponentHost sch2=sc2.getServiceComponentHost(host1);
ServiceComponentHost sch3=sc1.getServiceComponentHost(host2);
ServiceComponentHost sch4=sc2.getServiceComponentHost(host2);
ServiceComponentHost sch5=sc3.getServiceComponentHost(host1);
ServiceComponentHost sch6=sc4.getServiceComponentHost(host2);
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INIT);
sc3.setDesiredState(State.STARTED);
sc4.setDesiredState(State.INSTALLED);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INSTALLED);
sch3.setDesiredState(State.INSTALLED);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.INSTALLED);
sch6.setDesiredState(State.INSTALLED);
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.INSTALLED);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
sch6.setState(State.INSTALLED);
Set reqs=new HashSet();
ServiceRequest req1, req2;
try {
reqs.clear();
req1=new ServiceRequest(clusterName,serviceName1,State.STARTED.toString());
reqs.add(req1);
ServiceResourceProviderTest.updateServices(controller,reqs,mapRequestProps,true,false);
fail("Expected failure for invalid state update");
}
catch ( Exception e) {
}
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INSTALLED);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.INSTALLED);
sch2.setDesiredState(State.INSTALLED);
sch3.setDesiredState(State.INSTALLED);
sch4.setDesiredState(State.INSTALLED);
sch5.setDesiredState(State.INSTALLED);
sch1.setState(State.INIT);
sch2.setState(State.INSTALLED);
sch3.setState(State.INIT);
sch4.setState(State.INSTALLED);
sch5.setState(State.INSTALLED);
try {
reqs.clear();
req1=new ServiceRequest(clusterName,serviceName1,State.STARTED.toString());
reqs.add(req1);
ServiceResourceProviderTest.updateServices(controller,reqs,mapRequestProps,true,false);
fail("Expected failure for invalid state update");
}
catch ( Exception e) {
}
s1.setDesiredState(State.INSTALLED);
s2.setDesiredState(State.INSTALLED);
sc1.setDesiredState(State.STARTED);
sc2.setDesiredState(State.INSTALLED);
sc3.setDesiredState(State.STARTED);
sch1.setDesiredState(State.STARTED);
sch2.setDesiredState(State.STARTED);
sch3.setDesiredState(State.STARTED);
sch4.setDesiredState(State.STARTED);
sch5.setDesiredState(State.STARTED);
sch1.setState(State.INSTALLED);
sch2.setState(State.INSTALLED);
sch3.setState(State.INSTALLED);
sch4.setState(State.STARTED);
sch5.setState(State.INSTALLED);
reqs.clear();
req1=new ServiceRequest(clusterName,serviceName1,State.STARTED.toString());
req2=new ServiceRequest(clusterName,serviceName2,State.STARTED.toString());
reqs.add(req1);
reqs.add(req2);
RequestStatusResponse trackAction=ServiceResourceProviderTest.updateServices(controller,reqs,mapRequestProps,true,false);
Assert.assertEquals(State.STARTED,s1.getDesiredState());
Assert.assertEquals(State.STARTED,s2.getDesiredState());
Assert.assertEquals(State.STARTED,sc1.getDesiredState());
Assert.assertEquals(State.STARTED,sc2.getDesiredState());
Assert.assertEquals(State.STARTED,sc3.getDesiredState());
Assert.assertEquals(State.INSTALLED,sc4.getDesiredState());
Assert.assertEquals(State.STARTED,sch1.getDesiredState());
Assert.assertEquals(State.STARTED,sch2.getDesiredState());
Assert.assertEquals(State.STARTED,sch3.getDesiredState());
Assert.assertEquals(State.STARTED,sch4.getDesiredState());
Assert.assertEquals(State.STARTED,sch5.getDesiredState());
Assert.assertEquals(State.INSTALLED,sch6.getDesiredState());
Assert.assertEquals(State.INSTALLED,sch1.getState());
Assert.assertEquals(State.INSTALLED,sch2.getState());
Assert.assertEquals(State.INSTALLED,sch3.getState());
Assert.assertEquals(State.STARTED,sch4.getState());
Assert.assertEquals(State.INSTALLED,sch5.getState());
Assert.assertEquals(State.INSTALLED,sch6.getState());
long requestId=trackAction.getRequestId();
List stages=actionDB.getAllStages(requestId);
for ( Stage stage : stages) {
LOG.debug("Stage dump: " + stage.toString());
}
Assert.assertTrue(!stages.isEmpty());
Assert.assertEquals(3,stages.size());
Stage stage1=null, stage2=null, stage3=null;
for ( Stage s : stages) {
if (s.getStageId() == 0) {
stage1=s;
}
if (s.getStageId() == 1) {
stage2=s;
}
if (s.getStageId() == 2) {
stage3=s;
}
}
Assert.assertEquals(2,stage1.getExecutionCommands(host1).size());
Assert.assertEquals(1,stage1.getExecutionCommands(host2).size());
Assert.assertEquals(1,stage2.getExecutionCommands(host1).size());
Assert.assertNotNull(stage1.getExecutionCommandWrapper(host1,"NAMENODE"));
Assert.assertNotNull(stage1.getExecutionCommandWrapper(host1,"DATANODE"));
Assert.assertNotNull(stage1.getExecutionCommandWrapper(host2,"NAMENODE"));
Assert.assertNotNull(stage2.getExecutionCommandWrapper(host1,"HBASE_MASTER"));
Assert.assertNull(stage1.getExecutionCommandWrapper(host2,"DATANODE"));
Assert.assertNotNull(stage3.getExecutionCommandWrapper(host1,"HBASE_SERVICE_CHECK"));
Assert.assertNotNull(stage2.getExecutionCommandWrapper(host2,"HDFS_SERVICE_CHECK"));
Type type=new TypeToken>(){
}
.getType();
for ( Stage s : stages) {
for ( List list : s.getExecutionCommands().values()) {
for ( ExecutionCommandWrapper ecw : list) {
if (ecw.getExecutionCommand().getRole().contains("SERVICE_CHECK")) {
Map hostParams=StageUtils.getGson().fromJson(s.getHostParamsStage(),type);
Assert.assertNotNull(hostParams);
Assert.assertTrue(hostParams.size() > 0);
Assert.assertTrue(hostParams.containsKey("stack_version"));
Assert.assertEquals(hostParams.get("stack_version"),c1.getDesiredStackVersion().getStackVersion());
}
}
}
}
sch1.setState(State.STARTED);
sch2.setState(State.STARTED);
sch3.setState(State.STARTED);
sch4.setState(State.STARTED);
sch5.setState(State.STARTED);
reqs.clear();
req1=new ServiceRequest(clusterName,serviceName1,State.STARTED.toString());
req2=new ServiceRequest(clusterName,serviceName2,State.STARTED.toString());
reqs.add(req1);
reqs.add(req2);
trackAction=ServiceResourceProviderTest.updateServices(controller,reqs,mapRequestProps,true,false);
Assert.assertNull(trackAction);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier responses=controller.getStackServices(Collections.singleton(hdfsServiceRequest));
Assert.assertEquals(1,responses.size());
StackServiceResponse response=responses.iterator().next();
assertTrue(response.isServiceCheckSupported());
StackServiceRequest fakeServiceRequest=new StackServiceRequest(STACK_NAME,"2.0.8",FAKE_SERVICE_NAME);
responses=controller.getStackServices(Collections.singleton(fakeServiceRequest));
Assert.assertEquals(1,responses.size());
response=responses.iterator().next();
assertFalse(response.isServiceCheckSupported());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier set1=new HashSet();
ServiceComponentHostRequest r1=new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host1,State.INIT.toString());
ServiceComponentHostRequest r2=new ServiceComponentHostRequest(clusterName,serviceName,componentName2,host1,State.INIT.toString());
ServiceComponentHostRequest r3=new ServiceComponentHostRequest(clusterName,serviceName,componentName1,host2,State.INIT.toString());
ServiceComponentHostRequest r4=new ServiceComponentHostRequest(clusterName,serviceName,componentName2,host2,State.INIT.toString());
set1.add(r1);
set1.add(r2);
set1.add(r3);
set1.add(r4);
controller.createHostComponents(set1);
Assert.assertEquals(2,clusters.getCluster(clusterName).getServiceComponentHosts(host1).size());
Assert.assertEquals(2,clusters.getCluster(clusterName).getServiceComponentHosts(host2).size());
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName1).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName1).getServiceComponentHost(host2));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host1));
Assert.assertNotNull(clusters.getCluster(clusterName).getService(serviceName).getServiceComponent(componentName2).getServiceComponentHost(host2));
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier mapRequestProps=new HashMap();
mapRequestProps.put("context","Called from a test");
clusters.getCluster("foo1").setDesiredStackVersion(new StackId("HDP-0.2"));
createService(clusterName,serviceName,State.INIT);
Service s=clusters.getCluster(clusterName).getService(serviceName);
Assert.assertNotNull(s);
Assert.assertEquals(serviceName,s.getName());
Assert.assertEquals(State.INIT,s.getDesiredState());
Assert.assertEquals(clusterName,s.getCluster().getClusterName());
Set reqs=new HashSet();
ServiceRequest r;
try {
r=new ServiceRequest(clusterName,serviceName,State.INSTALLING.toString());
reqs.clear();
reqs.add(r);
ServiceResourceProviderTest.updateServices(controller,reqs,mapRequestProps,true,false);
fail("Expected fail for invalid state transition");
}
catch ( Exception e) {
}
r=new ServiceRequest(clusterName,serviceName,State.INSTALLED.toString());
reqs.clear();
reqs.add(r);
RequestStatusResponse trackAction=ServiceResourceProviderTest.updateServices(controller,reqs,mapRequestProps,true,false);
Assert.assertNull(trackAction);
}
UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hostAttributes=null;
HostRequest r1=new HostRequest("h1",null,hostAttributes);
r1.toString();
Set requests=new HashSet();
requests.add(r1);
try {
HostResourceProviderTest.createHosts(controller,requests);
fail("Create host should fail for non-bootstrapped host");
}
catch ( Exception e) {
}
clusters.addHost("h1");
clusters.addHost("h2");
setOsFamily(clusters.getHost("h1"),"redhat","5.9");
setOsFamily(clusters.getHost("h2"),"redhat","5.9");
clusters.getHost("h1").persist();
clusters.getHost("h2").persist();
requests.add(new HostRequest("h2","foo",new HashMap()));
try {
HostResourceProviderTest.createHosts(controller,requests);
fail("Create host should fail for invalid clusters");
}
catch ( Exception e) {
}
clusters.addCluster("foo",new StackId("HDP-0.1"));
Cluster c=clusters.getCluster("foo");
StackId stackId=new StackId("HDP-0.1");
c.setDesiredStackVersion(stackId);
c.setCurrentStackVersion(stackId);
helper.getOrCreateRepositoryVersion(stackId,stackId.getStackVersion());
c.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
HostResourceProviderTest.createHosts(controller,requests);
Assert.assertNotNull(clusters.getHost("h1"));
Assert.assertNotNull(clusters.getHost("h2"));
Assert.assertEquals(0,clusters.getClustersForHost("h1").size());
Assert.assertEquals(1,clusters.getClustersForHost("h2").size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier widgetEntities=widgetDAO.findAll();
List layoutEntities=widgetLayoutDAO.findAll();
Assert.assertNotNull(widgetEntities);
Assert.assertFalse(widgetEntities.isEmpty());
Assert.assertNotNull(layoutEntities);
Assert.assertFalse(layoutEntities.isEmpty());
WidgetEntity candidateVisibleEntity=null;
for ( WidgetEntity entity : widgetEntities) {
if (entity.getWidgetName().equals("OPEN_CONNECTIONS")) {
candidateVisibleEntity=entity;
}
}
Assert.assertNotNull(candidateVisibleEntity);
Assert.assertEquals("GRAPH",candidateVisibleEntity.getWidgetType());
Assert.assertEquals("ambari",candidateVisibleEntity.getAuthor());
Assert.assertEquals("CLUSTER",candidateVisibleEntity.getScope());
Assert.assertNotNull(candidateVisibleEntity.getMetrics());
Assert.assertNotNull(candidateVisibleEntity.getProperties());
Assert.assertNotNull(candidateVisibleEntity.getWidgetValues());
WidgetLayoutEntity candidateLayoutEntity=null;
for ( WidgetLayoutEntity entity : layoutEntities) {
if (entity.getLayoutName().equals("default_hbase_layout")) {
candidateLayoutEntity=entity;
}
}
Assert.assertNotNull(candidateLayoutEntity);
List layoutUserWidgetEntities=candidateLayoutEntity.getListWidgetLayoutUserWidgetEntity();
Assert.assertNotNull(layoutUserWidgetEntities);
Assert.assertEquals(4,layoutUserWidgetEntities.size());
Assert.assertEquals("RS_READS_WRITES",layoutUserWidgetEntities.get(0).getWidget().getWidgetName());
Assert.assertEquals("OPEN_CONNECTIONS",layoutUserWidgetEntities.get(1).getWidget().getWidgetName());
Assert.assertEquals("FILES_LOCAL",layoutUserWidgetEntities.get(2).getWidget().getWidgetName());
Assert.assertEquals("UPDATED_BLOCKED_TIME",layoutUserWidgetEntities.get(3).getWidget().getWidgetName());
Assert.assertEquals("HBASE_SUMMARY",layoutUserWidgetEntities.get(0).getWidget().getDefaultSectionName());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier responses=controller.getUsers(Collections.singleton(request));
Assert.assertEquals(3,responses.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier responses=controller.getStackConfigurations(Collections.singleton(request));
Assert.assertEquals(STACK_PROPERTIES_CNT,responses.size());
StackConfigurationRequest requestWithParams=new StackConfigurationRequest(STACK_NAME,STACK_VERSION,SERVICE_NAME,PROPERTY_NAME);
Set responsesWithParams=controller.getStackConfigurations(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( StackConfigurationResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getPropertyName(),PROPERTY_NAME);
}
StackConfigurationRequest invalidRequest=new StackConfigurationRequest(STACK_NAME,STACK_VERSION,SERVICE_NAME,NON_EXT_VALUE);
try {
controller.getStackConfigurations(Collections.singleton(invalidRequest));
}
catch ( StackAccessException e) {
}
}
InternalCallVerifier BooleanVerifier > requestConfigAttributes=new HashMap>();
Map> clusterConfigAttributes=new HashMap>();
Assert.assertTrue(controllerImpl.isAttributeMapsEqual(requestConfigAttributes,clusterConfigAttributes));
requestConfigAttributes.put("final",new HashMap());
requestConfigAttributes.get("final").put("c","true");
clusterConfigAttributes.put("final",new HashMap());
clusterConfigAttributes.get("final").put("c","true");
Assert.assertTrue(controllerImpl.isAttributeMapsEqual(requestConfigAttributes,clusterConfigAttributes));
clusterConfigAttributes.put("final2",new HashMap());
clusterConfigAttributes.get("final2").put("a","true");
Assert.assertFalse(controllerImpl.isAttributeMapsEqual(requestConfigAttributes,clusterConfigAttributes));
requestConfigAttributes.put("final2",new HashMap());
requestConfigAttributes.get("final2").put("a","false");
Assert.assertFalse(controllerImpl.isAttributeMapsEqual(requestConfigAttributes,clusterConfigAttributes));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resp=controller.getClusters(Collections.singleton(r));
Assert.assertEquals(4,resp.size());
r=new ClusterRequest(null,"c1",null,null);
resp=controller.getClusters(Collections.singleton(r));
Assert.assertEquals(1,resp.size());
Assert.assertEquals(c1.getClusterId(),resp.iterator().next().getClusterId().longValue());
r=new ClusterRequest(null,null,"HDP-0.1",null);
resp=controller.getClusters(Collections.singleton(r));
Assert.assertEquals(3,resp.size());
r=new ClusterRequest(null,null,"",null);
resp=controller.getClusters(Collections.singleton(r));
Assert.assertEquals(0,resp.size());
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier resp;
try {
ServiceResourceProviderTest.getServices(controller,Collections.singleton(r));
fail("Expected failure for invalid request");
}
catch ( Exception e) {
}
r=new ServiceRequest(c1.getClusterName(),null,null);
resp=ServiceResourceProviderTest.getServices(controller,Collections.singleton(r));
Assert.assertEquals(3,resp.size());
r=new ServiceRequest(c1.getClusterName(),s2.getName(),null);
resp=ServiceResourceProviderTest.getServices(controller,Collections.singleton(r));
Assert.assertEquals(1,resp.size());
Assert.assertEquals(s2.getName(),resp.iterator().next().getServiceName());
try {
r=new ServiceRequest(c2.getClusterName(),s1.getName(),null);
ServiceResourceProviderTest.getServices(controller,Collections.singleton(r));
fail("Expected failure for invalid service");
}
catch ( Exception e) {
}
r=new ServiceRequest(c1.getClusterName(),null,"INSTALLED");
resp=ServiceResourceProviderTest.getServices(controller,Collections.singleton(r));
Assert.assertEquals(2,resp.size());
r=new ServiceRequest(c2.getClusterName(),null,"INIT");
resp=ServiceResourceProviderTest.getServices(controller,Collections.singleton(r));
Assert.assertEquals(1,resp.size());
ServiceRequest r1, r2, r3;
r1=new ServiceRequest(c1.getClusterName(),null,"INSTALLED");
r2=new ServiceRequest(c2.getClusterName(),null,"INIT");
r3=new ServiceRequest(c2.getClusterName(),null,"INIT");
Set reqs=new HashSet();
reqs.addAll(Arrays.asList(r1,r2,r3));
resp=ServiceResourceProviderTest.getServices(controller,reqs);
Assert.assertEquals(3,resp.size());
}
Class: org.apache.ambari.server.controller.AmbariServerTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.AmbariSessionManagerTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.AuthToLocalBuilderTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier rules=Arrays.asList(new String[]{"RULE:[1:$1@$0](.*@FOOBAR.COM)s/@.*//","RULE:[1:$1@$0](.*@EXAMPLE.COM)s/@.*//","RULE:[1:$1@$0](.*@REALM2)s/@.*//","RULE:[1:$1@$0](.*@REALM1)s/@.*//","RULE:[1:$1@$0](.*@REALM3)s/@.*//","RULE:[2:$1@$0](dn@EXAMPLE.COM)s/.*/hdfs/","RULE:[2:$1@$0](hm@EXAMPLE.COM)s/.*/hbase/","RULE:[2:$1@$0](jhs@EXAMPLE.COM)s/.*/mapred/","RULE:[2:$1@$0](jn@EXAMPLE.COM)s/.*/hdfs/","RULE:[2:$1@$0](nn@EXAMPLE.COM)s/.*/hdfs/","RULE:[2:$1@$0](rm@EXAMPLE.COM)s/.*/yarn/","RULE:[2:$1@$0](rs@EXAMPLE.COM)s/.*/hbase/","DEFAULT"});
assertTrue(CollectionPresentationUtils.isStringPermutationOfCollection(builder.generate("EXAMPLE.COM"),rules,"\n",0,0));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.controller.BackgroundCustomCommandExecutionTest APIUtilityVerifier TestInitializer InternalCallVerifier EqualityVerifier HybridVerifier APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier requestProperties=new HashMap(){
{
put(REQUEST_CONTEXT_PROPERTY,"Refresh YARN Capacity Scheduler");
put("command","REBALANCEHDFS");
put("namenode","{\"threshold\":13}");
}
}
;
ExecuteActionRequest actionRequest=new ExecuteActionRequest("c1","REBALANCEHDFS",new HashMap(),false);
actionRequest.getResourceFilters().add(new RequestResourceFilter("HDFS","NAMENODE",Collections.singletonList("c6401")));
controller.createAction(actionRequest,requestProperties);
Mockito.verify(am,Mockito.times(1)).sendActions(requestCapture.capture(),any(ExecuteActionRequest.class));
Request request=requestCapture.getValue();
Assert.assertNotNull(request);
Assert.assertNotNull(request.getStages());
Assert.assertEquals(1,request.getStages().size());
Stage stage=request.getStages().iterator().next();
System.out.println(stage);
Assert.assertEquals(1,stage.getHosts().size());
List commands=stage.getExecutionCommands("c6401");
Assert.assertEquals(1,commands.size());
ExecutionCommand command=commands.get(0).getExecutionCommand();
Assert.assertEquals(AgentCommandType.BACKGROUND_EXECUTION_COMMAND,command.getCommandType());
Assert.assertEquals("{\"threshold\":13}",command.getCommandParams().get("namenode"));
}
catch ( Exception e) {
Assert.fail(e.getMessage());
}
}
Class: org.apache.ambari.server.controller.ClusterRequestTest InternalCallVerifier EqualityVerifier hostNames=new HashSet();
hostNames.add("h1");
ClusterRequest r1=new ClusterRequest(clusterId,clusterName,provisioningState,securityType,stackVersion.getStackId(),hostNames);
Assert.assertEquals(clusterId,r1.getClusterId());
Assert.assertEquals(clusterName,r1.getClusterName());
Assert.assertEquals(provisioningState,r1.getProvisioningState());
Assert.assertEquals(securityType,r1.getSecurityType());
Assert.assertEquals(stackVersion.getStackId(),r1.getStackVersion());
Assert.assertArrayEquals(hostNames.toArray(),r1.getHostNames().toArray());
r1.setClusterId(++clusterId);
r1.setHostNames(hostNames);
r1.setClusterName("foo1");
r1.setStackVersion("HDP-1.2.0");
r1.setProvisioningState(State.INSTALLED.name());
r1.setSecurityType(SecurityType.KERBEROS);
hostNames.add("h2");
Assert.assertEquals(clusterId,r1.getClusterId());
Assert.assertEquals("foo1",r1.getClusterName());
Assert.assertEquals(State.INSTALLED.name(),r1.getProvisioningState());
Assert.assertEquals(SecurityType.KERBEROS,r1.getSecurityType());
Assert.assertEquals("HDP-1.2.0",r1.getStackVersion());
Assert.assertArrayEquals(hostNames.toArray(),r1.getHostNames().toArray());
}
Class: org.apache.ambari.server.controller.ClusterResponseTest APIUtilityVerifier InternalCallVerifier EqualityVerifier hostNames=new HashSet();
hostNames.add("h1");
ClusterResponse r1=new ClusterResponse(clusterId,clusterName,provisioningState,securityType,hostNames,hostNames.size(),"bar",null);
Assert.assertEquals(clusterId,r1.getClusterId());
Assert.assertEquals(clusterName,r1.getClusterName());
Assert.assertEquals(provisioningState.name(),r1.getProvisioningState());
Assert.assertEquals(securityType.name(),r1.getSecurityType());
Assert.assertArrayEquals(hostNames.toArray(),r1.getHostNames().toArray());
Assert.assertEquals(Integer.valueOf(1),r1.getTotalHosts());
Assert.assertEquals("bar",r1.getDesiredStackVersion());
}
Class: org.apache.ambari.server.controller.KerberosHelperTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertiesKrb5Conf=new HashMap();
Map propertiesKerberosEnv=new HashMap();
propertiesKerberosEnv.put("realm","EXAMPLE.COM");
propertiesKerberosEnv.put("kdc_type","mit-kdc");
propertiesKerberosEnv.put("password_length","20");
propertiesKerberosEnv.put("password_min_lowercase_letters","1");
propertiesKerberosEnv.put("password_min_uppercase_letters","1");
propertiesKerberosEnv.put("password_min_digits","1");
propertiesKerberosEnv.put("password_min_punctuation","0");
propertiesKerberosEnv.put("password_min_whitespace","0");
Config configKrb5Conf=createMock(Config.class);
expect(configKrb5Conf.getProperties()).andReturn(propertiesKrb5Conf).times(1);
Config configKerberosEnv=createMock(Config.class);
expect(configKerberosEnv.getProperties()).andReturn(propertiesKerberosEnv).times(1);
Host host1=createMockHost("host1");
Host host2=createMockHost("host3");
Host host3=createMockHost("host2");
Map service1Component1HostMap=new HashMap();
service1Component1HostMap.put("host1",createMockServiceComponentHost());
Map service2Component1HostMap=new HashMap();
service2Component1HostMap.put("host2",createMockServiceComponentHost());
Map service1ComponentMap=new HashMap();
service1ComponentMap.put("COMPONENT11",createMockComponent("COMPONENT11",true,service1Component1HostMap));
Map service2ComponentMap=new HashMap();
service2ComponentMap.put("COMPONENT21",createMockComponent("COMPONENT21",true,service2Component1HostMap));
Service service1=createMockService("SERVICE1",service1ComponentMap);
Service service2=createMockService("SERVICE2",service2ComponentMap);
Map servicesMap=new HashMap();
servicesMap.put("SERVICE1",service1);
servicesMap.put("SERVICE2",service2);
Cluster cluster=createMock(Cluster.class);
expect(cluster.getDesiredConfigByType("krb5-conf")).andReturn(configKrb5Conf).times(1);
expect(cluster.getDesiredConfigByType("kerberos-env")).andReturn(configKerberosEnv).times(1);
expect(cluster.getSecurityType()).andReturn(SecurityType.KERBEROS).times(1);
expect(cluster.getCurrentStackVersion()).andReturn(new StackId("HDP","2.2")).times(1);
expect(cluster.getClusterName()).andReturn("c1").times(4);
expect(cluster.getHosts()).andReturn(Arrays.asList(host1,host2,host3)).times(1);
expect(cluster.getServices()).andReturn(servicesMap).times(1);
Map kerberosDescriptorProperties=new HashMap();
kerberosDescriptorProperties.put("additional_realms","");
kerberosDescriptorProperties.put("keytab_dir","/etc/security/keytabs");
kerberosDescriptorProperties.put("realm","${kerberos-env/realm}");
ArrayList service1Component1Identities=new ArrayList();
service1Component1Identities.add(createMockIdentityDescriptor("s1c1_1.user",createMockPrincipalDescriptor("s1c1_1@${realm}",KerberosPrincipalType.USER,"s1c1",null),createMockKeytabDescriptor("s1c1_1.user.keytab",null)));
service1Component1Identities.add(createMockIdentityDescriptor("s1c1_1.service",createMockPrincipalDescriptor("s1c1_1/_HOST@${realm}",KerberosPrincipalType.SERVICE,"s1c1",null),createMockKeytabDescriptor("s1c1_1.service.keytab",null)));
HashMap service1ComponentDescriptorMap=new HashMap();
service1ComponentDescriptorMap.put("COMPONENT11",createMockComponentDescriptor("COMPONENT11",service1Component1Identities,null));
List service1Identities=new ArrayList();
service1Identities.add(createMockIdentityDescriptor("s1_1.user",createMockPrincipalDescriptor("s1_1@${realm}",KerberosPrincipalType.USER,"s1",null),createMockKeytabDescriptor("s1_1.user.keytab",null)));
service1Identities.add(createMockIdentityDescriptor("s1_1.service",createMockPrincipalDescriptor("s1/_HOST@${realm}",KerberosPrincipalType.SERVICE,"s1",null),createMockKeytabDescriptor("s1.service.keytab",null)));
KerberosServiceDescriptor service1KerberosDescriptor=createMockServiceDescriptor("SERVICE1",service1ComponentDescriptorMap,service1Identities);
ArrayList service2Component1Identities=new ArrayList();
service2Component1Identities.add(createMockIdentityDescriptor("s2_1.user",createMockPrincipalDescriptor("s2_1@${realm}",KerberosPrincipalType.USER,"s2",null),createMockKeytabDescriptor("s2_1.user.keytab",null)));
service2Component1Identities.add(createMockIdentityDescriptor("s2c1_1.service",createMockPrincipalDescriptor("s2c1_1/_HOST@${realm}",KerberosPrincipalType.SERVICE,"s2c1",null),createMockKeytabDescriptor("s2c1_1.service.keytab",null)));
HashMap service2ComponentDescriptorMap=new HashMap();
service2ComponentDescriptorMap.put("COMPONENT21",createMockComponentDescriptor("COMPONENT21",service2Component1Identities,null));
KerberosServiceDescriptor service2KerberosDescriptor=createMockServiceDescriptor("SERVICE2",service2ComponentDescriptorMap,null);
KerberosDescriptor kerberosDescriptor=createMock(KerberosDescriptor.class);
expect(kerberosDescriptor.getProperties()).andReturn(kerberosDescriptorProperties);
expect(kerberosDescriptor.getService("SERVICE1")).andReturn(service1KerberosDescriptor).times(1);
expect(kerberosDescriptor.getService("SERVICE2")).andReturn(service2KerberosDescriptor).times(1);
setupGetDescriptorFromStack(kerberosDescriptor);
Map> existingConfigurations=new HashMap>();
existingConfigurations.put("kerberos-env",propertiesKerberosEnv);
Set services=new HashSet(){
{
add("SERVICE1");
add("SERVICE2");
}
}
;
Capture capturePrincipal=newCapture(CaptureType.ALL);
Capture capturePrincipalForKeytab=newCapture(CaptureType.ALL);
CreatePrincipalsServerAction createPrincipalsServerAction=injector.getInstance(CreatePrincipalsServerAction.class);
expect(createPrincipalsServerAction.createPrincipal(capture(capturePrincipal),eq(false),anyObject(Map.class),anyObject(KerberosOperationHandler.class),isNull(ActionLog.class))).andReturn(new CreatePrincipalsServerAction.CreatePrincipalResult("anything","password",1)).times(3);
CreateKeytabFilesServerAction createKeytabFilesServerAction=injector.getInstance(CreateKeytabFilesServerAction.class);
expect(createKeytabFilesServerAction.createKeytab(capture(capturePrincipalForKeytab),eq("password"),eq(1),anyObject(KerberosOperationHandler.class),eq(true),eq(true),isNull(ActionLog.class))).andReturn(new Keytab()).times(3);
replayAll();
AmbariMetaInfo ambariMetaInfo=injector.getInstance(AmbariMetaInfo.class);
ambariMetaInfo.init();
CredentialStoreService credentialStoreService=injector.getInstance(CredentialStoreService.class);
credentialStoreService.setCredential(cluster.getClusterName(),KerberosHelper.KDC_ADMINISTRATOR_CREDENTIAL_ALIAS,new PrincipalKeyCredential("principal","password"),CredentialStoreType.TEMPORARY);
KerberosHelper kerberosHelper=injector.getInstance(KerberosHelper.class);
kerberosHelper.ensureHeadlessIdentities(cluster,existingConfigurations,services);
verifyAll();
List capturedPrincipals=capturePrincipal.getValues();
assertEquals(3,capturedPrincipals.size());
assertTrue(capturedPrincipals.contains("s1_1@EXAMPLE.COM"));
assertTrue(capturedPrincipals.contains("s1c1_1@EXAMPLE.COM"));
assertTrue(capturedPrincipals.contains("s2_1@EXAMPLE.COM"));
List capturedPrincipalsForKeytab=capturePrincipalForKeytab.getValues();
assertEquals(3,capturedPrincipalsForKeytab.size());
assertTrue(capturedPrincipalsForKeytab.contains("s1_1@EXAMPLE.COM"));
assertTrue(capturedPrincipalsForKeytab.contains("s1c1_1@EXAMPLE.COM"));
assertTrue(capturedPrincipalsForKeytab.contains("s2_1@EXAMPLE.COM"));
}
InternalCallVerifier EqualityVerifier emptyMap()));
assertEquals(null,kerberosHelper.getManageIdentitiesDirective(new HashMap(){
{
put(KerberosHelper.DIRECTIVE_MANAGE_KERBEROS_IDENTITIES,null);
put("some_directive_0","false");
put("some_directive_1",null);
}
}
));
assertEquals(null,kerberosHelper.getManageIdentitiesDirective(new HashMap(){
{
put("some_directive_0","false");
put("some_directive_1",null);
}
}
));
}
InternalCallVerifier EqualityVerifier (){
{
put(KerberosHelper.DIRECTIVE_MANAGE_KERBEROS_IDENTITIES,"true");
put("some_directive_0","false");
put("some_directive_1",null);
}
}
));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier hosts=Arrays.asList(hostA,hostB,hostC);
final Map kerberosEnvProperties=new HashMap(){
{
put("kdc_type","mit-kdc");
put("realm","FOOBAR.COM");
put("case_insensitive_username_rules","false");
}
}
;
final Config kerberosEnvConfig=createMock(Config.class);
expect(kerberosEnvConfig.getProperties()).andReturn(kerberosEnvProperties).atLeastOnce();
final Map krb5ConfProperties=createMock(Map.class);
final Config krb5ConfConfig=createMock(Config.class);
expect(krb5ConfConfig.getProperties()).andReturn(krb5ConfProperties).atLeastOnce();
final KerberosPrincipalDescriptor principalDescriptor1=createMockPrincipalDescriptor("service1/_HOST@${realm}",KerberosPrincipalType.SERVICE,"service1user","service1-site/service.kerberos.principal");
final KerberosPrincipalDescriptor principalDescriptor1a=createMockPrincipalDescriptor("component1a/_HOST@${realm}",KerberosPrincipalType.SERVICE,"service1user","service1-site/component1a.kerberos.principal");
final KerberosPrincipalDescriptor principalDescriptor1b=createMockPrincipalDescriptor("component1b/_HOST@${realm}",KerberosPrincipalType.SERVICE,"service1user","service1-site/component1b.kerberos.principal");
final KerberosPrincipalDescriptor principalDescriptor2a=createMockPrincipalDescriptor("component2a/_HOST@${realm}",KerberosPrincipalType.SERVICE,"service2user","service2-site/component2a.kerberos.principal");
final KerberosPrincipalDescriptor principalDescriptor2b=createMockPrincipalDescriptor("component2b/_HOST@${realm}",KerberosPrincipalType.SERVICE,"service2user","service2-site/component2b.kerberos.principal");
final KerberosPrincipalDescriptor principalDescriptor3a=createMockPrincipalDescriptor("component3a/_HOST@${realm}",KerberosPrincipalType.SERVICE,"service3user","service3-site/component3a.kerberos.principal");
final KerberosKeytabDescriptor keytabDescriptor1=createMockKeytabDescriptor("keytab1","service1-site/service.kerberos.keytab");
final KerberosKeytabDescriptor keytabDescriptor1a=createMockKeytabDescriptor("keytab1a","service1-site/component1a.kerberos.keytab");
final KerberosKeytabDescriptor keytabDescriptor1b=createMockKeytabDescriptor("keytab1b","service1-site/component1b.kerberos.keytab");
final KerberosKeytabDescriptor keytabDescriptor2a=createMockKeytabDescriptor("keytab2a","service2-site/component2a.kerberos.keytab");
final KerberosKeytabDescriptor keytabDescriptor2b=createMockKeytabDescriptor("keytab2b","service2-site/component2b.kerberos.keytab");
final KerberosKeytabDescriptor keytabDescriptor3a=createMockKeytabDescriptor("keytab3a","service3-site/component3a.kerberos.keytab");
final KerberosIdentityDescriptor identityDescriptor1=createMockIdentityDescriptor("identity1",principalDescriptor1,keytabDescriptor1);
final KerberosIdentityDescriptor identityDescriptor1a=createMockIdentityDescriptor("identity1a",principalDescriptor1a,keytabDescriptor1a);
final KerberosIdentityDescriptor identityDescriptor1b=createMockIdentityDescriptor("identity1b",principalDescriptor1b,keytabDescriptor1b);
final KerberosIdentityDescriptor identityDescriptor2a=createMockIdentityDescriptor("identity2a",principalDescriptor2a,keytabDescriptor2a);
final KerberosIdentityDescriptor identityDescriptor2b=createMockIdentityDescriptor("identity2b",principalDescriptor2b,keytabDescriptor2b);
final KerberosIdentityDescriptor identityDescriptor3a=createMockIdentityDescriptor("identity3a",principalDescriptor3a,keytabDescriptor3a);
final KerberosComponentDescriptor componentDescriptor1a=createMockComponentDescriptor("COMPONENT1A",new ArrayList(){
{
add(identityDescriptor1a);
}
}
,new HashMap(){
{
put("service1-site",createMockConfigurationDescriptor(Collections.singletonMap("component1a.property","${replacement1}")));
}
}
);
final KerberosComponentDescriptor componentDescriptor1b=createMockComponentDescriptor("COMPONENT1B",new ArrayList(){
{
add(identityDescriptor1b);
}
}
,new HashMap(){
{
put("service1-site",createMockConfigurationDescriptor(Collections.singletonMap("component1b.property","${type1/replacement1}")));
}
}
);
final KerberosComponentDescriptor componentDescriptor2a=createMockComponentDescriptor("COMPONENT2A",new ArrayList(){
{
add(identityDescriptor2a);
}
}
,new HashMap(){
{
put("service2-site",createMockConfigurationDescriptor(Collections.singletonMap("component2a.property","${type1/replacement2}")));
}
}
);
final KerberosComponentDescriptor componentDescriptor2b=createMockComponentDescriptor("COMPONENT2B",new ArrayList(){
{
add(identityDescriptor2b);
}
}
,new HashMap(){
{
put("service2-site",createMockConfigurationDescriptor(Collections.singletonMap("component2b.property","${type2/replacement1}")));
}
}
);
final KerberosComponentDescriptor componentDescriptor3a=createMockComponentDescriptor("COMPONENT3A",new ArrayList(){
{
add(identityDescriptor3a);
}
}
,new HashMap(){
{
put("service3-site",createMockConfigurationDescriptor(Collections.singletonMap("component3a.property","${type3/replacement1}")));
put("core-site",createMockConfigurationDescriptor(Collections.singletonMap("component3b.property","${type3/replacement2}")));
}
}
);
final KerberosServiceDescriptor serviceDescriptor1=createMockServiceDescriptor("SERVICE1",new HashMap(){
{
put("COMPONENT1A",componentDescriptor1a);
put("COMPONENT1B",componentDescriptor1b);
}
}
,new ArrayList(){
{
add(identityDescriptor1);
}
}
);
final KerberosServiceDescriptor serviceDescriptor2=createMockServiceDescriptor("SERVICE2",new HashMap(){
{
put("COMPONENT2A",componentDescriptor2a);
put("COMPONENT2B",componentDescriptor2b);
}
}
,Collections.emptyList());
final KerberosServiceDescriptor serviceDescriptor3=createMockServiceDescriptor("SERVICE3",new HashMap(){
{
put("COMPONENT3A",componentDescriptor3a);
}
}
,Collections.emptyList());
final Map kerberosDescriptorProperties=new HashMap();
kerberosDescriptorProperties.put("realm","${kerberos-env/realm}");
final KerberosDescriptor kerberosDescriptor=createMock(KerberosDescriptor.class);
expect(kerberosDescriptor.getProperties()).andReturn(kerberosDescriptorProperties).atLeastOnce();
expect(kerberosDescriptor.getServices()).andReturn(new HashMap(){
{
put("SERVICE1",serviceDescriptor1);
put("SERVICE2",serviceDescriptor2);
put("SERVICE3",serviceDescriptor3);
}
}
).atLeastOnce();
expect(kerberosDescriptor.getService("SERVICE1")).andReturn(serviceDescriptor1).atLeastOnce();
expect(kerberosDescriptor.getService("SERVICE2")).andReturn(serviceDescriptor2).atLeastOnce();
expect(kerberosDescriptor.getService("SERVICE3")).andReturn(serviceDescriptor3).atLeastOnce();
expect(kerberosDescriptor.getProperty("additional_realms")).andReturn(null).atLeastOnce();
expect(kerberosDescriptor.getIdentities()).andReturn(null).atLeastOnce();
expect(kerberosDescriptor.getAuthToLocalProperties()).andReturn(Collections.singleton("core-site/auth.to.local")).atLeastOnce();
final ResourceProvider artifactResourceProvider=createMock(ArtifactResourceProvider.class);
expect(artifactResourceProvider.getResources(anyObject(Request.class),anyObject(Predicate.class))).andReturn(Collections.emptySet()).atLeastOnce();
expect(metaInfo.getKerberosDescriptor("HDP","2.2")).andReturn(kerberosDescriptor).atLeastOnce();
expect(clusterController.ensureResourceProvider(Resource.Type.Artifact)).andReturn(artifactResourceProvider).atLeastOnce();
RecommendationResponse.BlueprintConfigurations coreSiteRecommendation=createMock(RecommendationResponse.BlueprintConfigurations.class);
expect(coreSiteRecommendation.getProperties()).andReturn(Collections.singletonMap("newPropertyRecommendation","newPropertyRecommendation"));
RecommendationResponse.BlueprintConfigurations newTypeRecommendation=createMock(RecommendationResponse.BlueprintConfigurations.class);
expect(newTypeRecommendation.getProperties()).andReturn(Collections.singletonMap("newTypeRecommendation","newTypeRecommendation"));
RecommendationResponse.BlueprintConfigurations type1Recommendation=createMock(RecommendationResponse.BlueprintConfigurations.class);
expect(type1Recommendation.getProperties()).andReturn(Collections.singletonMap("replacement1","not replaced"));
RecommendationResponse.BlueprintConfigurations service1SiteRecommendation=createMock(RecommendationResponse.BlueprintConfigurations.class);
expect(service1SiteRecommendation.getProperties()).andReturn(Collections.singletonMap("component1b.property","replaced value"));
Map configurations=new HashMap();
configurations.put("core-site",coreSiteRecommendation);
configurations.put("new-type",newTypeRecommendation);
configurations.put("type1",type1Recommendation);
configurations.put("service1-site",service1SiteRecommendation);
RecommendationResponse.Blueprint blueprint=createMock(RecommendationResponse.Blueprint.class);
expect(blueprint.getConfigurations()).andReturn(configurations).once();
RecommendationResponse.Recommendation recommendations=createMock(RecommendationResponse.Recommendation.class);
expect(recommendations.getBlueprint()).andReturn(blueprint).once();
RecommendationResponse recommendationResponse=createMock(RecommendationResponse.class);
expect(recommendationResponse.getRecommendations()).andReturn(recommendations).once();
StackAdvisorHelper stackAdvisorHelper=injector.getInstance(StackAdvisorHelper.class);
expect(stackAdvisorHelper.recommend(anyObject(StackAdvisorRequest.class))).andReturn(null).once();
expect(stackAdvisorHelper.recommend(anyObject(StackAdvisorRequest.class))).andReturn(recommendationResponse).once();
final Service service1=createMockService("SERVICE1",new HashMap(){
{
put("COMPONENT1A",createMockComponent("COMPONENT1A",true,new HashMap(){
{
put("hostA",createMockServiceComponentHost());
}
}
));
put("COMPONENT1B",createMockComponent("COMPONENT1B",false,new HashMap(){
{
put("hostB",createMockServiceComponentHost());
put("hostC",createMockServiceComponentHost());
}
}
));
}
}
);
final Service service2=createMockService("SERVICE2",new HashMap(){
{
put("COMPONENT2A",createMockComponent("COMPONENT2A",true,new HashMap(){
{
put("hostA",createMockServiceComponentHost());
}
}
));
put("COMPONENT2B",createMockComponent("COMPONENT2B",false,new HashMap(){
{
put("hostB",createMockServiceComponentHost());
put("hostC",createMockServiceComponentHost());
}
}
));
}
}
);
final Service service3=createMockService("SERVICE3",new HashMap(){
{
put("COMPONENT3A",createMockComponent("COMPONENT3A",true,new HashMap(){
{
put("hostA",createMockServiceComponentHost());
}
}
));
}
}
);
final Cluster cluster=createMock(Cluster.class);
expect(cluster.getDesiredConfigByType("krb5-conf")).andReturn(krb5ConfConfig).atLeastOnce();
expect(cluster.getDesiredConfigByType("kerberos-env")).andReturn(kerberosEnvConfig).atLeastOnce();
expect(cluster.getSecurityType()).andReturn(SecurityType.KERBEROS).atLeastOnce();
expect(cluster.getCurrentStackVersion()).andReturn(new StackId("HDP","2.2")).atLeastOnce();
expect(cluster.getClusterName()).andReturn("c1").atLeastOnce();
expect(cluster.getHosts()).andReturn(hosts).anyTimes();
expect(cluster.getServices()).andReturn(new HashMap(){
{
put("SERVICE1",service1);
put("SERVICE2",service2);
put("SERVICE3",service3);
}
}
).anyTimes();
expect(cluster.isBluePrintDeployed()).andReturn(false).atLeastOnce();
final Map> existingConfigurations=new HashMap>(){
{
put("kerberos-env",kerberosEnvProperties);
put("",new HashMap(){
{
put("replacement1","value1");
}
}
);
put("type1",new HashMap(){
{
put("replacement1","value2");
put("replacement2","value3");
}
}
);
put("type2",new HashMap(){
{
put("replacement1","value4");
put("replacement2","value5");
}
}
);
put("type3",new HashMap(){
{
put("replacement1","value6");
put("replacement2","value7");
}
}
);
}
}
;
replayAll();
injector.getInstance(AmbariMetaInfo.class).init();
Map> updates1=kerberosHelper.getServiceConfigurationUpdates(cluster,existingConfigurations,new HashSet(Arrays.asList("SERVICE1","SERVICE2","SERVICE3")),false,true,true);
Map> updates2=kerberosHelper.getServiceConfigurationUpdates(cluster,existingConfigurations,new HashSet(Arrays.asList("SERVICE1","SERVICE3")),false,true,true);
verifyAll();
Map> expectedUpdates=new HashMap>(){
{
put("service1-site",new HashMap(){
{
put("service.kerberos.principal","service1/_HOST@FOOBAR.COM");
put("service.kerberos.keytab","keytab1");
put("component1a.kerberos.principal","component1a/_HOST@FOOBAR.COM");
put("component1a.kerberos.keytab","keytab1a");
put("component1a.property","value1");
put("component1b.kerberos.principal","component1b/_HOST@FOOBAR.COM");
put("component1b.kerberos.keytab","keytab1b");
put("component1b.property","value2");
}
}
);
put("service2-site",new HashMap(){
{
put("component2a.kerberos.principal","component2a/_HOST@FOOBAR.COM");
put("component2a.kerberos.keytab","keytab2a");
put("component2a.property","value3");
put("component2b.kerberos.principal","component2b/_HOST@FOOBAR.COM");
put("component2b.kerberos.keytab","keytab2b");
put("component2b.property","value4");
}
}
);
put("service3-site",new HashMap(){
{
put("component3a.kerberos.principal","component3a/_HOST@FOOBAR.COM");
put("component3a.kerberos.keytab","keytab3a");
put("component3a.property","value6");
}
}
);
put("core-site",new HashMap(){
{
put("auth.to.local","RULE:[1:$1@$0](.*@FOOBAR.COM)s/@.*//\n" + "RULE:[2:$1@$0](component1a@FOOBAR.COM)s/.*/service1user/\n" + "RULE:[2:$1@$0](component1b@FOOBAR.COM)s/.*/service1user/\n"+ "RULE:[2:$1@$0](component2a@FOOBAR.COM)s/.*/service2user/\n"+ "RULE:[2:$1@$0](component2b@FOOBAR.COM)s/.*/service2user/\n"+ "RULE:[2:$1@$0](component3a@FOOBAR.COM)s/.*/service3user/\n"+ "RULE:[2:$1@$0](service1@FOOBAR.COM)s/.*/service1user/\n"+ "DEFAULT");
put("component3b.property","value7");
}
}
);
}
}
;
assertEquals(expectedUpdates,updates1);
expectedUpdates.remove("service2-site");
expectedUpdates.get("core-site").put("newPropertyRecommendation","newPropertyRecommendation");
expectedUpdates.get("service1-site").put("component1b.property","replaced value");
expectedUpdates.put("new-type",new HashMap(){
{
put("newTypeRecommendation","newTypeRecommendation");
}
}
);
assertEquals(expectedUpdates,updates2);
Map> expectedExistingConfigurations=new HashMap>(){
{
put("kerberos-env",new HashMap(){
{
put("kdc_type","mit-kdc");
put("realm","FOOBAR.COM");
put("case_insensitive_username_rules","false");
}
}
);
put("",new HashMap(){
{
put("replacement1","value1");
}
}
);
put("type1",new HashMap(){
{
put("replacement1","value2");
put("replacement2","value3");
}
}
);
put("type2",new HashMap(){
{
put("replacement1","value4");
put("replacement2","value5");
}
}
);
put("type3",new HashMap(){
{
put("replacement1","value6");
put("replacement2","value7");
}
}
);
}
}
;
assertEquals(expectedExistingConfigurations,existingConfigurations);
}
InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier (){
{
put(KerberosHelper.DIRECTIVE_MANAGE_KERBEROS_IDENTITIES,"false");
put("some_directive_0","false");
put("some_directive_1",null);
}
}
));
}
Class: org.apache.ambari.server.controller.LdapSyncRequestTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier names=new HashSet();
names.add("name1");
LdapSyncRequest request=new LdapSyncRequest(LdapSyncSpecEntity.SyncType.SPECIFIC,names);
names=new HashSet();
names.add("name2");
names.add("name3");
request.addPrincipalNames(names);
Set principalNames=request.getPrincipalNames();
Assert.assertEquals(3,principalNames.size());
Assert.assertTrue(principalNames.contains("name1"));
Assert.assertTrue(principalNames.contains("name2"));
Assert.assertTrue(principalNames.contains("name3"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier names=new HashSet();
names.add("name1");
names.add("name2");
names.add("name3");
LdapSyncRequest request=new LdapSyncRequest(LdapSyncSpecEntity.SyncType.SPECIFIC,names);
Set principalNames=request.getPrincipalNames();
Assert.assertEquals(3,principalNames.size());
Assert.assertTrue(principalNames.contains("name1"));
Assert.assertTrue(principalNames.contains("name2"));
Assert.assertTrue(principalNames.contains("name3"));
}
Class: org.apache.ambari.server.controller.MaintenanceStateHelperTest APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier candidates=new HashSet();
candidates.add("host1");
candidates.add("host2");
candidates.add("host3");
candidates.add("host4");
Injector injector=createStrictMock(Injector.class);
MaintenanceStateHelper maintenanceStateHelper=createMockBuilder(MaintenanceStateHelper.class).withConstructor(injector).createNiceMock();
replay(predicate,maintenanceStateHelper);
Set ignored=maintenanceStateHelper.filterHostsInMaintenanceState(candidates,predicate);
verify(predicate,maintenanceStateHelper);
Assert.assertEquals(candidates.size(),2);
Assert.assertTrue(candidates.contains("host2"));
Assert.assertTrue(candidates.contains("host4"));
Assert.assertEquals(ignored.size(),2);
Assert.assertTrue(ignored.contains("host1"));
Assert.assertTrue(ignored.contains("host3"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier hosts=new ArrayList();
hosts.add("host1");
hosts.add("host2");
resourceFilter=new RequestResourceFilter("HDFS",null,hosts);
Assert.assertEquals(Resource.Type.Cluster,maintenanceStateHelper.guessOperationLevel(resourceFilter));
resourceFilter=new RequestResourceFilter(null,null,hosts);
Assert.assertEquals(Resource.Type.Host,maintenanceStateHelper.guessOperationLevel(resourceFilter));
resourceFilter=new RequestResourceFilter("HDFS","NAMENODE",hosts);
Assert.assertEquals(Resource.Type.HostComponent,maintenanceStateHelper.guessOperationLevel(resourceFilter));
}
Class: org.apache.ambari.server.controller.RefreshYarnCapacitySchedulerReleaseConfigTest APIUtilityVerifier InternalCallVerifier EqualityVerifier (),null)));
controller.updateClusters(Collections.singleton(cr),null);
ServiceComponentHostRequest r=new ServiceComponentHostRequest("c1",null,null,null,null);
r.setStaleConfig("true");
Set resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(4,resps.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier responsesWithParams=controller.getStackServices(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( StackServiceResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getServiceName(),"YARN");
Assert.assertTrue(responseWithParams.getConfigTypes().containsKey("capacity-scheduler"));
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier (),null)));
controller.updateClusters(Collections.singleton(cr),null);
ServiceComponentHostRequest r=new ServiceComponentHostRequest("c1",null,null,null,null);
r.setStaleConfig("true");
Set resps=controller.getHostComponents(Collections.singleton(r));
Assert.assertEquals(1,resps.size());
Assert.assertEquals(true,configHelper.isStaleConfigs(clusters.getCluster("c1").getService("YARN").getServiceComponent("RESOURCEMANAGER").getServiceComponentHost("c6401")));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier responsesWithParams=controller.getStackServices(Collections.singleton(requestWithParams));
Assert.assertEquals(1,responsesWithParams.size());
for ( StackServiceResponse responseWithParams : responsesWithParams) {
Assert.assertEquals(responseWithParams.getServiceName(),"YARN");
Assert.assertTrue(responseWithParams.getConfigTypes().containsKey("capacity-scheduler"));
}
}
Class: org.apache.ambari.server.controller.RootServiceResponseFactoryTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier rootServices=responseFactory.getRootServices(request);
assertEquals(RootServiceResponseFactory.Services.values().length,rootServices.size());
request=null;
rootServices=responseFactory.getRootServices(request);
assertEquals(RootServiceResponseFactory.Services.values().length,rootServices.size());
try {
request=new RootServiceRequest("XXX");
rootServices=responseFactory.getRootServices(request);
}
catch ( Exception e) {
assertTrue(e instanceof ObjectNotFoundException);
}
request=new RootServiceRequest(RootServiceResponseFactory.Services.AMBARI.name());
rootServices=responseFactory.getRootServices(request);
assertEquals(1,rootServices.size());
assertTrue(rootServices.contains(new RootServiceResponse(RootServiceResponseFactory.Services.AMBARI.name())));
}
IterativeVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier rootServiceComponents;
try {
rootServiceComponents=responseFactory.getRootServiceComponents(request);
}
catch ( Exception e) {
assertTrue(e instanceof ObjectNotFoundException);
}
RootServiceResponseFactory.Components ambariServerComponent=RootServiceResponseFactory.Components.AMBARI_SERVER;
request=new RootServiceComponentRequest(null,ambariServerComponent.name());
try {
rootServiceComponents=responseFactory.getRootServiceComponents(request);
}
catch ( Exception e) {
assertTrue(e instanceof ObjectNotFoundException);
}
request=new RootServiceComponentRequest(RootServiceResponseFactory.Services.AMBARI.name(),null);
rootServiceComponents=responseFactory.getRootServiceComponents(request);
assertEquals(RootServiceResponseFactory.Services.AMBARI.getComponents().length,rootServiceComponents.size());
String ambariVersion=ambariMetaInfo.getServerVersion();
for (int i=0; i < RootServiceResponseFactory.Services.AMBARI.getComponents().length; i++) {
Components component=RootServiceResponseFactory.Services.AMBARI.getComponents()[i];
if (component.name().equals(ambariServerComponent.name())) {
for ( RootServiceComponentResponse response : rootServiceComponents) {
if (response.getComponentName().equals(ambariServerComponent.name())) {
assertEquals(ambariVersion,response.getComponentVersion());
assertEquals(1,response.getProperties().size(),1);
assertTrue(response.getProperties().containsKey("jdk_location"));
}
}
}
else {
assertTrue(rootServiceComponents.contains(new RootServiceComponentResponse(component.name(),RootServiceResponseFactory.NOT_APPLICABLE,Collections.emptyMap())));
}
}
request=new RootServiceComponentRequest(RootServiceResponseFactory.Services.AMBARI.name(),RootServiceResponseFactory.Services.AMBARI.getComponents()[0].name());
rootServiceComponents=responseFactory.getRootServiceComponents(request);
assertEquals(1,rootServiceComponents.size());
for ( RootServiceComponentResponse response : rootServiceComponents) {
if (response.getComponentName().equals(RootServiceResponseFactory.Services.AMBARI.getComponents()[0].name())) {
assertEquals(ambariVersion,response.getComponentVersion());
assertEquals(2,response.getProperties().size());
assertTrue(response.getProperties().containsKey("jdk_location"));
assertTrue(response.getProperties().containsKey("java.version"));
}
}
request=new RootServiceComponentRequest(RootServiceResponseFactory.Services.AMBARI.name(),"XXX");
try {
rootServiceComponents=responseFactory.getRootServiceComponents(request);
}
catch ( Exception e) {
assertTrue(e instanceof ObjectNotFoundException);
}
}
Class: org.apache.ambari.server.controller.StackServiceResponseTest InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.controller.gsinstaller.GSInstallerClusterProviderTest InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
Assert.assertEquals("ambari",resources.iterator().next().getPropertyValue(GSInstallerClusterProvider.CLUSTER_NAME_PROPERTY_ID));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
Resource next=resources.iterator().next();
Assert.assertEquals("ambari",next.getPropertyValue(GSInstallerClusterProvider.CLUSTER_NAME_PROPERTY_ID));
Assert.assertEquals("HDP-1.2.0",next.getPropertyValue(GSInstallerClusterProvider.CLUSTER_VERSION_PROPERTY_ID));
predicate=new PredicateBuilder().property(GSInstallerClusterProvider.CLUSTER_NAME_PROPERTY_ID).equals("non-existent Cluster").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
Class: org.apache.ambari.server.controller.gsinstaller.GSInstallerComponentProviderTest InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(24,resources.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
predicate=new PredicateBuilder().property(GSInstallerComponentProvider.COMPONENT_COMPONENT_NAME_PROPERTY_ID).equals("TASKTRACKER").or().property(GSInstallerComponentProvider.COMPONENT_COMPONENT_NAME_PROPERTY_ID).equals("GANGLIA_MONITOR").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(2,resources.size());
predicate=new PredicateBuilder().property(GSInstallerComponentProvider.COMPONENT_COMPONENT_NAME_PROPERTY_ID).equals("BadComponent").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
Class: org.apache.ambari.server.controller.gsinstaller.GSInstallerHostComponentProviderTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(5,resources.size());
predicate=new PredicateBuilder().property(GSInstallerHostComponentProvider.HOST_COMPONENT_HOST_NAME_PROPERTY_ID).equals("UnknownHost").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest("HostRoles"),predicate);
Assert.assertEquals(3,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("STARTED",resource.getPropertyValue(GSInstallerHostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID));
}
stateProvider.setHealthy(false);
Thread.sleep(501);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(3,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("INIT",resource.getPropertyValue(GSInstallerHostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID));
}
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(3,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("STARTED",resource.getPropertyValue(GSInstallerHostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID));
}
stateProvider.setHealthy(false);
Thread.sleep(501);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(3,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("INIT",resource.getPropertyValue(GSInstallerHostComponentProvider.HOST_COMPONENT_STATE_PROPERTY_ID));
}
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(32,resources.size());
}
Class: org.apache.ambari.server.controller.gsinstaller.GSInstallerHostProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest("Hosts"),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("HEALTHY",resource.getPropertyValue(GSInstallerHostProvider.HOST_STATE_PROPERTY_ID));
stateProvider.setHealthy(false);
Thread.sleep(501);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
resource=resources.iterator().next();
Assert.assertEquals("INIT",resource.getPropertyValue(GSInstallerHostProvider.HOST_STATE_PROPERTY_ID));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
predicate=new PredicateBuilder().property(GSInstallerHostProvider.HOST_NAME_PROPERTY_ID).equals("ip-10-190-97-104.ec2.internal").or().property(GSInstallerHostProvider.HOST_NAME_PROPERTY_ID).equals("ip-10-8-113-183.ec2.internal").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(2,resources.size());
predicate=new PredicateBuilder().property(GSInstallerHostProvider.HOST_NAME_PROPERTY_ID).equals("unknownHost").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("HEALTHY",resource.getPropertyValue(GSInstallerHostProvider.HOST_STATE_PROPERTY_ID));
stateProvider.setHealthy(false);
Thread.sleep(501);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
resource=resources.iterator().next();
Assert.assertEquals("INIT",resource.getPropertyValue(GSInstallerHostProvider.HOST_STATE_PROPERTY_ID));
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(5,resources.size());
}
Class: org.apache.ambari.server.controller.gsinstaller.GSInstallerServiceProviderTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
predicate=new PredicateBuilder().property(GSInstallerServiceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("HDFS").or().property(GSInstallerServiceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("GANGLIA").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(2,resources.size());
predicate=new PredicateBuilder().property(GSInstallerServiceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("NO SERVICE").toPredicate();
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertTrue(resources.isEmpty());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest("ServiceInfo"),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("STARTED",resource.getPropertyValue(GSInstallerServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
stateProvider.setHealthy(false);
Thread.sleep(501);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
resource=resources.iterator().next();
Assert.assertEquals("INIT",resource.getPropertyValue(GSInstallerServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("STARTED",resource.getPropertyValue(GSInstallerServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
stateProvider.setHealthy(false);
Thread.sleep(501);
resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
resource=resources.iterator().next();
Assert.assertEquals("INIT",resource.getPropertyValue(GSInstallerServiceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
}
InternalCallVerifier EqualityVerifier resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(11,resources.size());
}
Class: org.apache.ambari.server.controller.internal.AbstractJDBCResourceProviderTest InternalCallVerifier EqualityVerifier requestedIds=new TreeSet();
requestedIds.add(property1);
requestedIds.add("none1");
requestedIds.add(property2);
AbstractJDBCResourceProvider provider=new TestAbstractJDBCResourceProviderImpl(requestedIds,null);
Assert.assertEquals(TestFields.field1.toString() + "," + TestFields.field2.toString(),provider.getDBFieldString(requestedIds));
Assert.assertEquals(TestFields.field1.toString(),provider.getDBFieldString(Collections.singleton(property1)));
Assert.assertEquals("",provider.getDBFieldString(Collections.singleton("none1")));
Assert.assertEquals(TestFields.field1,provider.getDBField(property1));
Assert.assertEquals(TestFields.field2,provider.getDBField(property2));
ResultSet rs=createMock(ResultSet.class);
expect(rs.getString(TestFields.field1.toString())).andReturn("1").once();
expect(rs.getLong(TestFields.field2.toString())).andReturn(2l).once();
expect(rs.getInt(TestFields.field1.toString())).andReturn(3).once();
replay(rs);
Resource r=new ResourceImpl((Resource.Type)null);
provider.setString(r,property1,rs,requestedIds);
provider.setString(r,"none2",rs,requestedIds);
Assert.assertEquals("1",r.getPropertyValue(property1));
r=new ResourceImpl((Resource.Type)null);
provider.setLong(r,property2,rs,requestedIds);
provider.setLong(r,"none2",rs,requestedIds);
Assert.assertEquals(2l,r.getPropertyValue(property2));
r=new ResourceImpl((Resource.Type)null);
provider.setInt(r,property1,rs,requestedIds);
provider.setInt(r,"none2",rs,requestedIds);
Assert.assertEquals(3,r.getPropertyValue(property1));
verify(rs);
}
Class: org.apache.ambari.server.controller.internal.AbstractPropertyProviderTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyInfoMap=provider.getPropertyInfoMap("NAMENODE","metrics/cpu/cpu_aidle");
Assert.assertEquals(1,propertyInfoMap.size());
Assert.assertTrue(propertyInfoMap.containsKey("metrics/cpu/cpu_aidle"));
propertyInfoMap=provider.getPropertyInfoMap("NAMENODE","metrics/disk");
Assert.assertEquals(3,propertyInfoMap.size());
Assert.assertTrue(propertyInfoMap.containsKey("metrics/disk/disk_free"));
Assert.assertTrue(propertyInfoMap.containsKey("metrics/disk/disk_total"));
Assert.assertTrue(propertyInfoMap.containsKey("metrics/disk/part_max_used"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > componentMetrics=PropertyHelper.getMetricPropertyIds(Resource.Type.HostComponent);
AbstractPropertyProvider provider=new TestPropertyProvider(componentMetrics);
Map flumeMetrics=provider.getComponentMetrics().get("FLUME_HANDLER");
int metricsBefore=flumeMetrics.size();
String specificMetric="metrics/flume/arg1/CHANNEL/arg2/ChannelCapacity";
String specificPropertyInfoId="arg1.CHANNEL.arg2.ChannelCapacity";
Map componentMetricMap=provider.getComponentMetrics().get("FLUME_HANDLER");
Assert.assertNull(flumeMetrics.get(specificMetric));
provider.updateComponentMetricMap(componentMetricMap,specificMetric);
Assert.assertEquals(metricsBefore + 1,flumeMetrics.size());
Assert.assertNotNull(flumeMetrics.get(specificMetric));
Assert.assertEquals(specificPropertyInfoId,flumeMetrics.get(specificMetric).getPropertyId());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyInfoMap=provider.getPropertyInfoMap("DATANODE","metrics");
Assert.assertEquals(86,propertyInfoMap.size());
propertyInfoMap=provider.getPropertyInfoMap("DATANODE","metrics/rpc/RpcQueueTime_avg_time");
Assert.assertEquals(1,propertyInfoMap.size());
Assert.assertTrue(propertyInfoMap.containsKey("metrics/rpc/RpcQueueTime_avg_time"));
propertyInfoMap=provider.getPropertyInfoMap("DATANODE","metrics/rpc/");
Assert.assertEquals(12,propertyInfoMap.size());
Assert.assertTrue(propertyInfoMap.containsKey("metrics/rpc/RpcQueueTime_avg_time"));
}
Class: org.apache.ambari.server.controller.internal.AbstractResourceProviderTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier updatePropertyMap=new HashMap();
updatePropertyMap.put("SomeProperty","SomeUpdateValue");
updatePropertyMap.put("SomeOtherProperty",99);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.property("ClusterName").equals("c1").and().property("ResourceName").equals("r1").toPredicate();
Set> propertyMaps=provider.getPropertyMaps(updatePropertyMap,predicate);
Assert.assertEquals(1,propertyMaps.size());
Map map=propertyMaps.iterator().next();
Assert.assertEquals(4,map.size());
Assert.assertEquals("c1",map.get("ClusterName"));
Assert.assertEquals("r1",map.get("ResourceName"));
Assert.assertEquals("SomeUpdateValue",map.get("SomeProperty"));
Assert.assertEquals(99,map.get("SomeOtherProperty"));
pb=new PredicateBuilder();
predicate=pb.property("ClusterName").equals("c1").and().begin().property("ResourceName").equals("r1").or().property("ResourceName").equals("r2").end().toPredicate();
propertyMaps=provider.getPropertyMaps(updatePropertyMap,predicate);
Assert.assertEquals(2,propertyMaps.size());
for ( Map map2 : propertyMaps) {
Assert.assertEquals(4,map2.size());
Assert.assertEquals("c1",map2.get("ClusterName"));
Object resourceName=map2.get("ResourceName");
Assert.assertTrue(resourceName.equals("r1") || resourceName.equals("r2"));
Assert.assertEquals("SomeUpdateValue",map2.get("SomeProperty"));
Assert.assertEquals(99,map2.get("SomeOtherProperty"));
}
predicate=new AlwaysPredicate();
propertyMaps=provider.getPropertyMaps(updatePropertyMap,predicate);
Assert.assertEquals(4,propertyMaps.size());
for ( Map map2 : propertyMaps) {
Assert.assertEquals(4,map2.size());
Assert.assertEquals("c1",map2.get("ClusterName"));
Object resourceName=map2.get("ResourceName");
Assert.assertTrue(resourceName.equals("r1") || resourceName.equals("r2") || resourceName.equals("r3")|| resourceName.equals("r4"));
Assert.assertEquals("SomeUpdateValue",map2.get("SomeProperty"));
Assert.assertEquals(99,map2.get("SomeOtherProperty"));
}
}
InternalCallVerifier BooleanVerifier propertyIds=new HashSet();
propertyIds.add("p1");
propertyIds.add("foo");
propertyIds.add("cat1/foo");
propertyIds.add("cat2/bar");
propertyIds.add("cat2/baz");
propertyIds.add("cat3/sub1/bam");
propertyIds.add("cat4/sub2/sub3/bat");
Map keyPropertyIds=new HashMap();
AmbariManagementController managementController=createMock(AmbariManagementController.class);
MaintenanceStateHelper maintenanceStateHelper=createNiceMock(MaintenanceStateHelper.class);
replay(maintenanceStateHelper);
AbstractResourceProvider provider=new ServiceResourceProvider(propertyIds,keyPropertyIds,managementController,maintenanceStateHelper);
Set supportedPropertyIds=provider.getPropertyIds();
Assert.assertTrue(supportedPropertyIds.containsAll(propertyIds));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyIds=new HashSet();
propertyIds.add("foo");
propertyIds.add("cat1/foo");
propertyIds.add("cat2/bar");
propertyIds.add("cat2/baz");
propertyIds.add("cat3/sub1/bam");
propertyIds.add("cat4/sub2/sub3/bat");
propertyIds.add("cat5/subcat5/map");
Map keyPropertyIds=new HashMap();
AmbariManagementController managementController=createMock(AmbariManagementController.class);
MaintenanceStateHelper maintenanceStateHelper=createNiceMock(MaintenanceStateHelper.class);
replay(maintenanceStateHelper);
AbstractResourceProvider provider=new ServiceResourceProvider(propertyIds,keyPropertyIds,managementController,maintenanceStateHelper);
Set unsupported=provider.checkPropertyIds(Collections.singleton("foo"));
Assert.assertTrue(unsupported.isEmpty());
Assert.assertTrue(provider.checkPropertyIds(Collections.singleton("cat5/subcat5/map/key")).isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("bar"));
Assert.assertEquals(1,unsupported.size());
Assert.assertTrue(unsupported.contains("bar"));
unsupported=provider.checkPropertyIds(Collections.singleton("cat1/foo"));
Assert.assertTrue(unsupported.isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("cat1"));
Assert.assertTrue(unsupported.isEmpty());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier propertyIds=new HashSet();
Map keyPropertyIds=new HashMap();
AmbariManagementController managementController=createMock(AmbariManagementController.class);
MaintenanceStateHelper maintenanceStateHelper=createNiceMock(MaintenanceStateHelper.class);
replay(maintenanceStateHelper);
AbstractResourceProvider provider=new ServiceResourceProvider(propertyIds,keyPropertyIds,managementController,maintenanceStateHelper);
RequestStatus status=provider.getRequestStatus(null);
Assert.assertNull(status.getRequestResource());
Assert.assertEquals(Collections.emptySet(),status.getAssociatedResources());
RequestStatusResponse response=new RequestStatusResponse(99L);
status=provider.getRequestStatus(response);
Resource resource=status.getRequestResource();
Assert.assertEquals(99L,resource.getPropertyValue("Requests/id"));
Assert.assertEquals(Collections.emptySet(),status.getAssociatedResources());
status=provider.getRequestStatus(response,null);
resource=status.getRequestResource();
Assert.assertEquals(99L,resource.getPropertyValue("Requests/id"));
Assert.assertEquals(Collections.emptySet(),status.getAssociatedResources());
Resource associatedResource=new ResourceImpl(Resource.Type.Service);
Set associatedResources=Collections.singleton(associatedResource);
status=provider.getRequestStatus(response,associatedResources);
resource=status.getRequestResource();
Assert.assertEquals(99L,resource.getPropertyValue("Requests/id"));
Assert.assertEquals(associatedResources,status.getAssociatedResources());
}
Class: org.apache.ambari.server.controller.internal.ActionResourceProviderTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier allDefinition=new ArrayList();
allDefinition.add(new ActionDefinition("a1",ActionType.SYSTEM,"fileName","HDFS","DATANODE","Does file exist",TargetHostType.ANY,Short.valueOf("100")));
allDefinition.add(new ActionDefinition("a2",ActionType.SYSTEM,"fileName","HDFS","DATANODE","Does file exist",TargetHostType.ANY,Short.valueOf("100")));
allDefinition.add(new ActionDefinition("a3",ActionType.SYSTEM,"fileName","HDFS","DATANODE","Does file exist",TargetHostType.ANY,Short.valueOf("100")));
Set allResponse=new HashSet();
for ( ActionDefinition definition : allDefinition) {
allResponse.add(definition.convertToResponse());
}
ActionDefinition namedDefinition=new ActionDefinition("a1",ActionType.SYSTEM,"fileName","HDFS","DATANODE","Does file exist",TargetHostType.ANY,Short.valueOf("100"));
Set nameResponse=new HashSet();
nameResponse.add(namedDefinition.convertToResponse());
expect(am.getAllActionDefinition()).andReturn(allDefinition).once();
expect(am.getActionDefinition("a1")).andReturn(namedDefinition).once();
replay(managementController,am);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(ActionResourceProvider.ACTION_NAME_PROPERTY_ID);
propertyIds.add(ActionResourceProvider.ACTION_TYPE_PROPERTY_ID);
propertyIds.add(ActionResourceProvider.DEFAULT_TIMEOUT_PROPERTY_ID);
propertyIds.add(ActionResourceProvider.DESCRIPTION_PROPERTY_ID);
propertyIds.add(ActionResourceProvider.INPUTS_PROPERTY_ID);
propertyIds.add(ActionResourceProvider.TARGET_COMPONENT_PROPERTY_ID);
propertyIds.add(ActionResourceProvider.TARGET_HOST_PROPERTY_ID);
propertyIds.add(ActionResourceProvider.TARGET_SERVICE_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,null);
Assert.assertEquals(allResponse.size(),resources.size());
for ( Resource resource : resources) {
String actionName=(String)resource.getPropertyValue(ActionResourceProvider.ACTION_NAME_PROPERTY_ID);
String actionType=(String)resource.getPropertyValue(ActionResourceProvider.ACTION_TYPE_PROPERTY_ID);
String defaultTimeout=(String)resource.getPropertyValue(ActionResourceProvider.DEFAULT_TIMEOUT_PROPERTY_ID);
String description=(String)resource.getPropertyValue(ActionResourceProvider.DESCRIPTION_PROPERTY_ID);
String inputs=(String)resource.getPropertyValue(ActionResourceProvider.INPUTS_PROPERTY_ID);
String comp=(String)resource.getPropertyValue(ActionResourceProvider.TARGET_COMPONENT_PROPERTY_ID);
String svc=(String)resource.getPropertyValue(ActionResourceProvider.TARGET_SERVICE_PROPERTY_ID);
String host=(String)resource.getPropertyValue(ActionResourceProvider.TARGET_HOST_PROPERTY_ID);
Assert.assertTrue(allResponse.contains(new ActionResponse(actionName,actionType,inputs,svc,comp,description,host,defaultTimeout)));
}
Predicate predicate=new PredicateBuilder().property(ActionResourceProvider.ACTION_NAME_PROPERTY_ID).equals("a1").toPredicate();
resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Assert.assertEquals("a1",resources.iterator().next().getPropertyValue(ActionResourceProvider.ACTION_NAME_PROPERTY_ID));
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.AlertDefinitionResourceProviderTest InternalCallVerifier EqualityVerifier results=provider.getResources(request,null);
assertEquals(0,results.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier entityCapture=new Capture();
dao.create(capture(entityCapture));
expectLastCall();
expect(definitionHash.invalidateHosts(EasyMock.anyObject(AlertDefinitionEntity.class))).andReturn(new HashSet()).atLeastOnce();
replay(amc,clusters,cluster,dao,definitionHash);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
MetricSource source=(MetricSource)getMockSource();
Map requestProps=new HashMap();
requestProps.put(AlertDefinitionResourceProvider.ALERT_DEF_CLUSTER_NAME,"c1");
requestProps.put(AlertDefinitionResourceProvider.ALERT_DEF_INTERVAL,"1");
requestProps.put(AlertDefinitionResourceProvider.ALERT_DEF_NAME,"my_def");
requestProps.put(AlertDefinitionResourceProvider.ALERT_DEF_SERVICE_NAME,"HDFS");
requestProps.put(AlertDefinitionResourceProvider.ALERT_DEF_SOURCE_TYPE,"METRIC");
requestProps.put("AlertDefinition/source/reporting/critical/text",source.getReporting().getCritical().getText());
requestProps.put("AlertDefinition/source/reporting/critical/value","1234.5");
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
AlertDefinitionResourceProvider provider=createProvider(amc);
provider.createResources(request);
Assert.assertTrue(entityCapture.hasCaptured());
AlertDefinitionEntity entity=entityCapture.getValue();
Assert.assertNotNull(entity);
String sourceJson=entity.getSource();
Gson gson=new Gson();
source=gson.fromJson(sourceJson,MetricSource.class);
assertEquals(new Double(1234.5d),source.getReporting().getCritical().getValue());
verify(amc,clusters,cluster,dao);
}
Class: org.apache.ambari.server.controller.internal.AlertResourceProviderTest APIUtilityVerifier InternalCallVerifier BooleanVerifier requestProperties=new HashSet();
requestProperties.add(AlertResourceProvider.ALERT_ID);
requestProperties.add(AlertResourceProvider.ALERT_DEFINITION_NAME);
Request request=PropertyHelper.getReadRequest(requestProperties);
Predicate predicate=new PredicateBuilder().property(AlertResourceProvider.ALERT_CLUSTER_NAME).equals("c1").toPredicate();
AlertResourceProvider provider=createProvider();
QueryResponse response=provider.queryForResources(request,predicate);
assertFalse(response.isPagedResponse());
PageRequest pageRequest=new PageRequestImpl(StartingPoint.Beginning,5,10,predicate,null);
request=PropertyHelper.getReadRequest(requestProperties,null,null,pageRequest,null);
response=provider.queryForResources(request,predicate);
assertTrue(response.isPagedResponse());
verify(m_dao);
}
Class: org.apache.ambari.server.controller.internal.AmbariPrivilegeResourceProviderTest InternalCallVerifier EqualityVerifier userEntities=new HashMap<>();
Map groupEntities=new HashMap<>();
Map resourceEntities=new HashMap();
resourceEntities.put(resourceEntity.getId(),viewInstanceEntity);
AmbariPrivilegeResourceProvider provider=new AmbariPrivilegeResourceProvider();
Resource resource=provider.toResource(privilegeEntity,userEntities,groupEntities,resourceEntities,provider.getPropertyIds());
Assert.assertEquals("Test View",resource.getPropertyValue(ViewPrivilegeResourceProvider.PRIVILEGE_INSTANCE_NAME_PROPERTY_ID));
Assert.assertEquals("TestView",resource.getPropertyValue(ViewPrivilegeResourceProvider.PRIVILEGE_VIEW_NAME_PROPERTY_ID));
Assert.assertEquals("1.2.3.4",resource.getPropertyValue(ViewPrivilegeResourceProvider.PRIVILEGE_VIEW_VERSION_PROPERTY_ID));
Assert.assertEquals(ResourceType.VIEW.name(),resource.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_TYPE_PROPERTY_ID));
verify(permissionEntity,principalTypeEntity,principalEntity,resourceTypeEntity,viewInstanceEntity,viewEntity,resourceEntity,privilegeEntity);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier userEntities=new LinkedList();
userEntities.add(ambariUserEntity);
userEntities.add(viewUserEntity);
userEntities.add(clusterUserEntity);
List privilegeEntities=new LinkedList();
privilegeEntities.add(ambariPrivilegeEntity);
privilegeEntities.add(viewPrivilegeEntity);
privilegeEntities.add(clusterPrivilegeEntity);
List clusterEntities=new LinkedList();
clusterEntities.add(clusterEntity);
ClusterDAO clusterDAO=injector.getInstance(ClusterDAO.class);
expect(clusterDAO.findAll()).andReturn(clusterEntities).atLeastOnce();
PrivilegeDAO privilegeDAO=injector.getInstance(PrivilegeDAO.class);
expect(privilegeDAO.findAll()).andReturn(privilegeEntities).atLeastOnce();
UserDAO userDAO=injector.getInstance(UserDAO.class);
expect(userDAO.findUsersByPrincipal(anyObject(List.class))).andReturn(userEntities).atLeastOnce();
GroupDAO groupDAO=injector.getInstance(GroupDAO.class);
expect(groupDAO.findGroupsByPrincipal(anyObject(List.class))).andReturn(Collections.emptyList()).atLeastOnce();
replayAll();
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator("admin"));
ResourceProvider provider=getResourceProvider(injector);
ViewRegistry.getInstance().addDefinition(viewEntity);
Set resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(3,resources.size());
Map resourceMap=new HashMap();
for ( Resource resource : resources) {
resourceMap.put(resource.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_ID_PROPERTY_ID),resource);
}
Resource resource1=resourceMap.get(31);
Assert.assertEquals(6,resource1.getPropertiesMap().get("PrivilegeInfo").size());
Assert.assertEquals("AMBARI.ADMINISTRATOR",resource1.getPropertyValue(AmbariPrivilegeResourceProvider.PERMISSION_NAME_PROPERTY_ID));
Assert.assertEquals("Administrator",resource1.getPropertyValue(AmbariPrivilegeResourceProvider.PERMISSION_LABEL_PROPERTY_ID));
Assert.assertEquals("joe",resource1.getPropertyValue(AmbariPrivilegeResourceProvider.PRINCIPAL_NAME_PROPERTY_ID));
Assert.assertEquals("USER",resource1.getPropertyValue(AmbariPrivilegeResourceProvider.PRINCIPAL_TYPE_PROPERTY_ID));
Assert.assertEquals(31,resource1.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_ID_PROPERTY_ID));
Assert.assertEquals("AMBARI",resource1.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_TYPE_PROPERTY_ID));
Resource resource2=resourceMap.get(32);
Assert.assertEquals(7,resource2.getPropertiesMap().get("PrivilegeInfo").size());
Assert.assertEquals("CLUSTER.USER",resource2.getPropertyValue(AmbariPrivilegeResourceProvider.PERMISSION_NAME_PROPERTY_ID));
Assert.assertEquals("Cluster User",resource2.getPropertyValue(AmbariPrivilegeResourceProvider.PERMISSION_LABEL_PROPERTY_ID));
Assert.assertEquals("jeff",resource2.getPropertyValue(AmbariPrivilegeResourceProvider.PRINCIPAL_NAME_PROPERTY_ID));
Assert.assertEquals("USER",resource2.getPropertyValue(AmbariPrivilegeResourceProvider.PRINCIPAL_TYPE_PROPERTY_ID));
Assert.assertEquals(32,resource2.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_ID_PROPERTY_ID));
Assert.assertEquals("cluster1",resource2.getPropertyValue(ClusterPrivilegeResourceProvider.PRIVILEGE_CLUSTER_NAME_PROPERTY_ID));
Assert.assertEquals("CLUSTER",resource2.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_TYPE_PROPERTY_ID));
Resource resource3=resourceMap.get(33);
Assert.assertEquals(9,resource3.getPropertiesMap().get("PrivilegeInfo").size());
Assert.assertEquals("VIEW.USER",resource3.getPropertyValue(AmbariPrivilegeResourceProvider.PERMISSION_NAME_PROPERTY_ID));
Assert.assertEquals("View User",resource3.getPropertyValue(AmbariPrivilegeResourceProvider.PERMISSION_LABEL_PROPERTY_ID));
Assert.assertEquals("bob",resource3.getPropertyValue(AmbariPrivilegeResourceProvider.PRINCIPAL_NAME_PROPERTY_ID));
Assert.assertEquals("USER",resource3.getPropertyValue(AmbariPrivilegeResourceProvider.PRINCIPAL_TYPE_PROPERTY_ID));
Assert.assertEquals(33,resource3.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_ID_PROPERTY_ID));
Assert.assertEquals("view",resource3.getPropertyValue(ViewPrivilegeResourceProvider.PRIVILEGE_VIEW_NAME_PROPERTY_ID));
Assert.assertEquals("1.0.1",resource3.getPropertyValue(ViewPrivilegeResourceProvider.PRIVILEGE_VIEW_VERSION_PROPERTY_ID));
Assert.assertEquals("inst1",resource3.getPropertyValue(ViewPrivilegeResourceProvider.PRIVILEGE_INSTANCE_NAME_PROPERTY_ID));
Assert.assertEquals("VIEW",resource3.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_TYPE_PROPERTY_ID));
verifyAll();
}
InternalCallVerifier EqualityVerifier userEntities=new HashMap<>();
Map groupEntities=new HashMap<>();
Map resourceEntities=new HashMap();
AmbariPrivilegeResourceProvider provider=new AmbariPrivilegeResourceProvider();
Resource resource=provider.toResource(privilegeEntity,userEntities,groupEntities,resourceEntities,provider.getPropertyIds());
Assert.assertEquals(ResourceType.AMBARI.name(),resource.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_TYPE_PROPERTY_ID));
verify(permissionEntity,principalTypeEntity,principalEntity,resourceTypeEntity,resourceEntity,privilegeEntity);
}
InternalCallVerifier EqualityVerifier userEntities=new HashMap<>();
Map groupEntities=new HashMap<>();
Map resourceEntities=new HashMap();
resourceEntities.put(resourceEntity.getId(),clusterEntity);
AmbariPrivilegeResourceProvider provider=new AmbariPrivilegeResourceProvider();
Resource resource=provider.toResource(privilegeEntity,userEntities,groupEntities,resourceEntities,provider.getPropertyIds());
Assert.assertEquals("TestCluster",resource.getPropertyValue(ClusterPrivilegeResourceProvider.PRIVILEGE_CLUSTER_NAME_PROPERTY_ID));
Assert.assertEquals(ResourceType.CLUSTER.name(),resource.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_TYPE_PROPERTY_ID));
verify(permissionEntity,principalTypeEntity,principalEntity,resourceTypeEntity,clusterEntity,resourceEntity,privilegeEntity);
}
InternalCallVerifier EqualityVerifier userEntities=new HashMap<>();
Map groupEntities=new HashMap<>();
Map resourceEntities=new HashMap();
resourceEntities.put(resourceEntity.getId(),viewInstanceEntity);
AmbariPrivilegeResourceProvider provider=new AmbariPrivilegeResourceProvider();
Resource resource=provider.toResource(privilegeEntity,userEntities,groupEntities,resourceEntities,provider.getPropertyIds());
Assert.assertEquals("Test View",resource.getPropertyValue(ViewPrivilegeResourceProvider.PRIVILEGE_INSTANCE_NAME_PROPERTY_ID));
Assert.assertEquals("TestView",resource.getPropertyValue(ViewPrivilegeResourceProvider.PRIVILEGE_VIEW_NAME_PROPERTY_ID));
Assert.assertEquals("1.2.3.4",resource.getPropertyValue(ViewPrivilegeResourceProvider.PRIVILEGE_VIEW_VERSION_PROPERTY_ID));
Assert.assertEquals(ResourceType.VIEW.name(),resource.getPropertyValue(AmbariPrivilegeResourceProvider.PRIVILEGE_TYPE_PROPERTY_ID));
verify(permissionEntity,principalTypeEntity,principalEntity,resourceTypeEntity,viewInstanceEntity,viewEntity,resourceEntity,privilegeEntity);
}
Class: org.apache.ambari.server.controller.internal.ArtifactResourceProviderTest InternalCallVerifier EqualityVerifier createEntityCapture=new Capture();
Map outerMap=new TreeMap();
Map childMap=new TreeMap();
outerMap.put("child",childMap);
childMap.put("childKey","childValue");
Map child2Map=new TreeMap();
childMap.put("child2",child2Map);
child2Map.put("child2Key","child2Value");
Map child3Map=new TreeMap();
child2Map.put("child3",child3Map);
Map child4Map=new TreeMap();
child3Map.put("child4",child4Map);
child4Map.put("child4Key","child4Value");
Set> propertySet=new HashSet>();
propertySet.add(outerMap);
propertySet.add(child4Map);
Map artifact_data=new TreeMap();
artifact_data.put("foo","bar");
artifact_data.put("child",childMap);
artifact_data.put("collection",propertySet);
TreeMap foreignKeys=new TreeMap();
foreignKeys.put("cluster","500");
Map requestInfoProps=new HashMap();
requestInfoProps.put(Request.REQUEST_INFO_BODY_PROPERTY,bodyJson);
Map properties=new HashMap();
properties.put("Artifacts/artifact_name","test-artifact");
properties.put("Artifacts/cluster_name","test-cluster");
properties.put("artifact_data/foo","bar");
properties.put("artifact_data/child/childKey","childValue");
properties.put("artifact_data/child/child2/child2Key","child2Value");
properties.put("artifact_data/child/child2/child3/child4/child4Key","child4Value");
Collection collectionProperties=new HashSet();
properties.put("artifact_data/collection",collectionProperties);
Map map1=new TreeMap();
collectionProperties.add(map1);
map1.put("foo","bar");
map1.put("child/childKey","childValue");
map1.put("child/child2/child2Key","child2Value");
map1.put("child/child2/child3/child4/child4Key","child4Value");
Map map2=new TreeMap();
collectionProperties.add(map2);
map2.put("child4Key","child4Value");
Set> requestProperties=Collections.singleton(properties);
expect(request.getRequestInfoProperties()).andReturn(requestInfoProps).anyTimes();
expect(request.getProperties()).andReturn(requestProperties).anyTimes();
expect(controller.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster("test-cluster")).andReturn(cluster).anyTimes();
expect(clusters.getClusterById(500L)).andReturn(cluster).anyTimes();
expect(cluster.getClusterId()).andReturn(500L).anyTimes();
expect(cluster.getClusterName()).andReturn("test-cluster").anyTimes();
expect(dao.findByNameAndForeignKeys(eq("test-artifact"),eq(foreignKeys))).andReturn(null).once();
dao.create(capture(createEntityCapture));
replay(dao,em,controller,request,clusters,cluster,entity,entity2);
resourceProvider.createResources(request);
ArtifactEntity createEntity=createEntityCapture.getValue();
assertEquals("test-artifact",createEntity.getArtifactName());
Map actualArtifactData=createEntity.getArtifactData();
assertEquals(artifact_data.size(),actualArtifactData.size());
assertEquals(artifact_data.get("foo"),actualArtifactData.get("foo"));
assertEquals(artifact_data.get("child"),actualArtifactData.get("child"));
assertEquals(artifact_data.get("collection"),new HashSet(((Collection)actualArtifactData.get("collection"))));
assertEquals(foreignKeys,createEntity.getForeignKeys());
}
BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyIds=new HashSet();
TreeMap foreignKeys=new TreeMap();
foreignKeys.put("cluster","500");
List entities=new ArrayList();
entities.add(entity);
entities.add(entity2);
Map artifact_data=Collections.singletonMap("foo","bar");
Map artifact_data2=Collections.singletonMap("foo2","bar2");
Map responseForeignKeys=new HashMap();
responseForeignKeys.put("cluster","500");
expect(controller.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster("test-cluster")).andReturn(cluster).anyTimes();
expect(clusters.getClusterById(500L)).andReturn(cluster).anyTimes();
expect(cluster.getClusterId()).andReturn(500L).anyTimes();
expect(cluster.getClusterName()).andReturn("test-cluster").anyTimes();
expect(request.getPropertyIds()).andReturn(propertyIds).anyTimes();
expect(dao.findByForeignKeys(eq(foreignKeys))).andReturn(entities).anyTimes();
expect(entity.getArtifactName()).andReturn("test-artifact").anyTimes();
expect(entity.getForeignKeys()).andReturn(responseForeignKeys).anyTimes();
expect(entity.getArtifactData()).andReturn(artifact_data).anyTimes();
expect(entity2.getArtifactName()).andReturn("test-artifact2").anyTimes();
expect(entity2.getForeignKeys()).andReturn(responseForeignKeys).anyTimes();
expect(entity2.getArtifactData()).andReturn(artifact_data2).anyTimes();
replay(dao,em,controller,request,clusters,cluster,entity,entity2);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.begin().property("Artifacts/cluster_name").equals("test-cluster").end().toPredicate();
Set response=resourceProvider.getResources(request,predicate);
assertEquals(2,response.size());
boolean artifact1Returned=false;
boolean artifact2Returned=false;
for ( Resource resource : response) {
if (resource.getPropertyValue("Artifacts/artifact_name").equals("test-artifact")) {
artifact1Returned=true;
assertEquals("bar",resource.getPropertyValue("artifact_data/foo"));
assertEquals("test-cluster",resource.getPropertyValue("Artifacts/cluster_name"));
}
else if (resource.getPropertyValue("Artifacts/artifact_name").equals("test-artifact2")) {
artifact2Returned=true;
assertEquals("bar2",resource.getPropertyValue("artifact_data/foo2"));
assertEquals("test-cluster",resource.getPropertyValue("Artifacts/cluster_name"));
}
else {
fail("unexpected artifact name");
}
}
assertTrue(artifact1Returned);
assertTrue(artifact2Returned);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier propertyIds=new HashSet();
TreeMap foreignKeys=new TreeMap();
foreignKeys.put("cluster","500");
Map childMap=new TreeMap();
childMap.put("childKey","childValue");
Map child2Map=new TreeMap();
childMap.put("child2",child2Map);
child2Map.put("child2Key","child2Value");
Map child3Map=new TreeMap();
child2Map.put("child3",child3Map);
Map child4Map=new TreeMap();
child3Map.put("child4",child4Map);
child4Map.put("child4Key","child4Value");
Map artifact_data=new TreeMap();
artifact_data.put("foo","bar");
artifact_data.put("child",childMap);
Map responseForeignKeys=new HashMap();
responseForeignKeys.put("cluster","500");
expect(controller.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster("test-cluster")).andReturn(cluster).anyTimes();
expect(clusters.getClusterById(500L)).andReturn(cluster).anyTimes();
expect(cluster.getClusterId()).andReturn(500L).anyTimes();
expect(cluster.getClusterName()).andReturn("test-cluster").anyTimes();
expect(request.getPropertyIds()).andReturn(propertyIds).anyTimes();
expect(dao.findByNameAndForeignKeys(eq("test-artifact"),eq(foreignKeys))).andReturn(entity).once();
expect(entity.getArtifactName()).andReturn("test-artifact").anyTimes();
expect(entity.getForeignKeys()).andReturn(responseForeignKeys).anyTimes();
expect(entity.getArtifactData()).andReturn(artifact_data).anyTimes();
replay(dao,em,controller,request,clusters,cluster,entity,entity2);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.begin().property("Artifacts/cluster_name").equals("test-cluster").and().property("Artifacts/artifact_name").equals("test-artifact").end().toPredicate();
Set response=resourceProvider.getResources(request,predicate);
assertEquals(1,response.size());
Resource resource=response.iterator().next();
Map> responseProperties=resource.getPropertiesMap();
assertEquals(5,responseProperties.size());
Map artifactDataMap=responseProperties.get("artifact_data");
assertEquals("bar",artifactDataMap.get("foo"));
assertEquals("test-artifact",resource.getPropertyValue("Artifacts/artifact_name"));
assertEquals("test-cluster",resource.getPropertyValue("Artifacts/cluster_name"));
assertEquals("bar",resource.getPropertyValue("artifact_data/foo"));
assertEquals("childValue",resource.getPropertyValue("artifact_data/child/childKey"));
assertEquals("child2Value",resource.getPropertyValue("artifact_data/child/child2/child2Key"));
assertEquals("child4Value",resource.getPropertyValue("artifact_data/child/child2/child3/child4/child4Key"));
}
BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier deleteEntityCapture=new Capture();
Capture deleteEntityCapture2=new Capture();
TreeMap foreignKeys=new TreeMap();
foreignKeys.put("cluster","500");
List entities=new ArrayList();
entities.add(entity);
entities.add(entity2);
Map artifact_data=Collections.singletonMap("foo","bar");
Map artifact_data2=Collections.singletonMap("foo2","bar2");
Map responseForeignKeys=new HashMap();
responseForeignKeys.put("cluster","500");
expect(controller.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster("test-cluster")).andReturn(cluster).anyTimes();
expect(clusters.getClusterById(500L)).andReturn(cluster).anyTimes();
expect(cluster.getClusterId()).andReturn(500L).anyTimes();
expect(cluster.getClusterName()).andReturn("test-cluster").anyTimes();
expect(entity.getArtifactName()).andReturn("test-artifact").anyTimes();
expect(entity.getForeignKeys()).andReturn(responseForeignKeys).anyTimes();
expect(entity.getArtifactData()).andReturn(artifact_data).anyTimes();
expect(entity2.getArtifactName()).andReturn("test-artifact2").anyTimes();
expect(entity2.getForeignKeys()).andReturn(responseForeignKeys).anyTimes();
expect(entity2.getArtifactData()).andReturn(artifact_data2).anyTimes();
expect(dao.findByForeignKeys(eq(foreignKeys))).andReturn(entities).once();
expect(dao.findByNameAndForeignKeys(eq("test-artifact"),eq(foreignKeys))).andReturn(entity).once();
dao.remove(capture(deleteEntityCapture));
expect(dao.findByNameAndForeignKeys(eq("test-artifact2"),eq(foreignKeys))).andReturn(entity2).once();
dao.remove(capture(deleteEntityCapture2));
replay(dao,em,controller,request,clusters,cluster,entity,entity2);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.begin().property("Artifacts/cluster_name").equals("test-cluster").end().toPredicate();
RequestStatus response=resourceProvider.deleteResources(predicate);
ArtifactEntity deleteEntity=deleteEntityCapture.getValue();
ArtifactEntity deleteEntity2=deleteEntityCapture2.getValue();
if (deleteEntity.getArtifactName().equals("test-artifact")) {
assertEquals("test-artifact2",deleteEntity2.getArtifactName());
}
else if (deleteEntity.getArtifactName().equals("test-artifact2")) {
assertEquals("test-artifact",deleteEntity2.getArtifactName());
}
else {
fail("Unexpected artifact name: " + deleteEntity.getArtifactName());
}
assertEquals(foreignKeys,deleteEntity.getForeignKeys());
assertEquals(foreignKeys,deleteEntity2.getForeignKeys());
assertEquals(RequestStatus.Status.Complete,response.getStatus());
verify(dao,em,controller,request,clusters,cluster,entity,entity2);
}
BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier requestInfoProps=new HashMap();
requestInfoProps.put(Request.REQUEST_INFO_BODY_PROPERTY,bodyJson);
Capture updateEntityCapture=new Capture();
Capture updateEntityCapture2=new Capture();
Set propertyIds=new HashSet();
TreeMap foreignKeys=new TreeMap();
foreignKeys.put("cluster","500");
List entities=new ArrayList();
entities.add(entity);
entities.add(entity2);
Map artifact_data=Collections.singletonMap("foo","bar");
Map artifact_data2=Collections.singletonMap("foo2","bar2");
Map responseForeignKeys=new HashMap();
responseForeignKeys.put("cluster","500");
Map properties=new HashMap();
properties.put("Artifacts/artifact_name","test-artifact");
properties.put("Artifacts/cluster_name","test-cluster");
properties.put("artifact_data/foo","bar");
properties.put("artifact_data/child/childKey","childValue");
properties.put("artifact_data/child/child2/child2Key","child2Value");
properties.put("artifact_data/child/child2/child3/child4/child4Key","child4Value");
Set> requestProperties=Collections.singleton(properties);
Collection collectionProperties=new HashSet();
properties.put("artifact_data/collection",collectionProperties);
expect(request.getProperties()).andReturn(requestProperties).anyTimes();
expect(request.getRequestInfoProperties()).andReturn(requestInfoProps).anyTimes();
expect(controller.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster("test-cluster")).andReturn(cluster).anyTimes();
expect(clusters.getClusterById(500L)).andReturn(cluster).anyTimes();
expect(cluster.getClusterId()).andReturn(500L).anyTimes();
expect(cluster.getClusterName()).andReturn("test-cluster").anyTimes();
expect(request.getPropertyIds()).andReturn(propertyIds).anyTimes();
expect(dao.findByForeignKeys(eq(foreignKeys))).andReturn(entities).anyTimes();
expect(entity.getArtifactName()).andReturn("test-artifact").anyTimes();
expect(entity.getForeignKeys()).andReturn(responseForeignKeys).anyTimes();
expect(entity.getArtifactData()).andReturn(artifact_data).anyTimes();
expect(entity2.getArtifactName()).andReturn("test-artifact2").anyTimes();
expect(entity2.getForeignKeys()).andReturn(responseForeignKeys).anyTimes();
expect(entity2.getArtifactData()).andReturn(artifact_data2).anyTimes();
expect(dao.merge(capture(updateEntityCapture))).andReturn(entity).once();
expect(dao.merge(capture(updateEntityCapture2))).andReturn(entity2).once();
replay(dao,em,controller,request,clusters,cluster,entity,entity2);
PredicateBuilder pb=new PredicateBuilder();
Predicate predicate=pb.begin().property("Artifacts/cluster_name").equals("test-cluster").end().toPredicate();
RequestStatus response=resourceProvider.updateResources(request,predicate);
ArtifactEntity updateEntity=updateEntityCapture.getValue();
ArtifactEntity updateEntity2=updateEntityCapture2.getValue();
Gson serializer=new Gson();
ArtifactEntity expected=new ArtifactEntity();
expected.setArtifactData((Map)serializer.>fromJson(bodyJson,Map.class).get("artifact_data"));
assertEquals(expected.getArtifactData(),updateEntity.getArtifactData());
assertEquals(expected.getArtifactData(),updateEntity2.getArtifactData());
if (updateEntity.getArtifactName().equals("test-artifact")) {
assertEquals("test-artifact2",updateEntity2.getArtifactName());
}
else if (updateEntity.getArtifactName().equals("test-artifact2")) {
assertEquals("test-artifact",updateEntity2.getArtifactName());
}
else {
fail("Unexpected artifact name: " + updateEntity.getArtifactName());
}
assertEquals(foreignKeys,updateEntity.getForeignKeys());
assertEquals(foreignKeys,updateEntity2.getForeignKeys());
assertEquals(RequestStatus.Status.Complete,response.getStatus());
verify(dao,em,controller,request,clusters,cluster,entity,entity2);
}
Class: org.apache.ambari.server.controller.internal.BaseBlueprintProcessorTest APIUtilityVerifier InternalCallVerifier EqualityVerifier emptySet());
expect(mockMgmtController.getStackLevelConfigurations((Set)anyObject())).andReturn(Collections.emptySet()).anyTimes();
final DependencyInfo hCatDependency=new TestDependencyInfo("HIVE/HCAT");
final DependencyInfo yarnClientDependency=new TestDependencyInfo("YARN/YARN_CLIENT");
final DependencyInfo tezClientDependency=new TestDependencyInfo("TEZ/TEZ_CLIENT");
final DependencyInfo mapReduceTwoClientDependency=new TestDependencyInfo("YARN/MAPREDUCE2_CLIENT");
mockSupport.replayAll();
Stack testStack=new Stack("HDP","2.1",mockMgmtController){
@Override public Collection getDependenciesForComponent( String component){
if (component.equals("FAKE_MONITORING_SERVER")) {
Set setOfDependencies=new HashSet();
setOfDependencies.add(hCatDependency);
setOfDependencies.add(yarnClientDependency);
setOfDependencies.add(tezClientDependency);
setOfDependencies.add(mapReduceTwoClientDependency);
return setOfDependencies;
}
return Collections.emptySet();
}
/**
* {@inheritDoc}
*/
@Override void registerConditionalDependencies(){
super.registerConditionalDependencies();
Map dependencyConditionalServiceMap=getDependencyConditionalServiceMap();
Collection monitoringDependencies=getDependenciesForComponent("FAKE_MONITORING_SERVER");
for ( DependencyInfo dependency : monitoringDependencies) {
if (dependency.getComponentName().equals("HCAT")) {
dependencyConditionalServiceMap.put(dependency,"HIVE");
}
else if (dependency.getComponentName().equals("OOZIE_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"OOZIE");
}
else if (dependency.getComponentName().equals("YARN_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"YARN");
}
else if (dependency.getComponentName().equals("TEZ_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"TEZ");
}
else if (dependency.getComponentName().equals("MAPREDUCE2_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"MAPREDUCE2");
}
}
}
}
;
assertEquals("Initial conditional dependency map should be empty",0,testStack.getDependencyConditionalServiceMap().size());
testStack.registerConditionalDependencies();
assertEquals("Set of conditional service mappings is an incorrect size",4,testStack.getDependencyConditionalServiceMap().size());
assertEquals("Incorrect service dependency for HCAT","HIVE",testStack.getDependencyConditionalServiceMap().get(hCatDependency));
assertEquals("Incorrect service dependency for YARN_CLIENT","YARN",testStack.getDependencyConditionalServiceMap().get(yarnClientDependency));
assertEquals("Incorrect service dependency for TEZ_CLIENT","TEZ",testStack.getDependencyConditionalServiceMap().get(tezClientDependency));
assertEquals("Incorrect service dependency for MAPREDUCE2_CLIENT","MAPREDUCE2",testStack.getDependencyConditionalServiceMap().get(mapReduceTwoClientDependency));
mockSupport.verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier emptySet());
expect(mockMgmtController.getStackLevelConfigurations((Set)anyObject())).andReturn(Collections.emptySet()).anyTimes();
final DependencyInfo hCatDependency=new TestDependencyInfo("HIVE/HCAT");
final DependencyInfo yarnClientDependency=new TestDependencyInfo("YARN/YARN_CLIENT");
final DependencyInfo tezClientDependency=new TestDependencyInfo("TEZ/TEZ_CLIENT");
final DependencyInfo oozieClientDependency=new TestDependencyInfo("OOZIE/OOZIE_CLIENT");
mockSupport.replayAll();
Stack testStack=new Stack("HDP","2.1",mockMgmtController){
@Override public Collection getDependenciesForComponent( String component){
if (component.equals("FAKE_MONITORING_SERVER")) {
Set setOfDependencies=new HashSet();
setOfDependencies.add(hCatDependency);
setOfDependencies.add(yarnClientDependency);
setOfDependencies.add(tezClientDependency);
setOfDependencies.add(oozieClientDependency);
return setOfDependencies;
}
return Collections.emptySet();
}
/**
* {@inheritDoc}
*/
@Override void registerConditionalDependencies(){
super.registerConditionalDependencies();
Map dependencyConditionalServiceMap=getDependencyConditionalServiceMap();
Collection monitoringDependencies=getDependenciesForComponent("FAKE_MONITORING_SERVER");
for ( DependencyInfo dependency : monitoringDependencies) {
if (dependency.getComponentName().equals("HCAT")) {
dependencyConditionalServiceMap.put(dependency,"HIVE");
}
else if (dependency.getComponentName().equals("OOZIE_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"OOZIE");
}
else if (dependency.getComponentName().equals("YARN_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"YARN");
}
else if (dependency.getComponentName().equals("TEZ_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"TEZ");
}
else if (dependency.getComponentName().equals("MAPREDUCE2_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"MAPREDUCE2");
}
}
}
}
;
assertEquals("Initial conditional dependency map should be empty",0,testStack.getDependencyConditionalServiceMap().size());
testStack.registerConditionalDependencies();
assertEquals("Set of conditional service mappings is an incorrect size",4,testStack.getDependencyConditionalServiceMap().size());
assertEquals("Incorrect service dependency for HCAT","HIVE",testStack.getDependencyConditionalServiceMap().get(hCatDependency));
assertEquals("Incorrect service dependency for YARN_CLIENT","YARN",testStack.getDependencyConditionalServiceMap().get(yarnClientDependency));
assertEquals("Incorrect service dependency for TEZ_CLIENT","TEZ",testStack.getDependencyConditionalServiceMap().get(tezClientDependency));
assertEquals("Incorrect service dependency for OOZIE_CLIENT","OOZIE",testStack.getDependencyConditionalServiceMap().get(oozieClientDependency));
mockSupport.verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier emptySet());
expect(mockMgmtController.getStackLevelConfigurations((Set)anyObject())).andReturn(Collections.emptySet()).anyTimes();
final DependencyInfo yarnClientDependency=new TestDependencyInfo("YARN/YARN_CLIENT");
final DependencyInfo tezClientDependency=new TestDependencyInfo("TEZ/TEZ_CLIENT");
final DependencyInfo mapReduceTwoClientDependency=new TestDependencyInfo("YARN/MAPREDUCE2_CLIENT");
final DependencyInfo oozieClientDependency=new TestDependencyInfo("OOZIE/OOZIE_CLIENT");
mockSupport.replayAll();
Stack testStack=new Stack("HDP","2.1",mockMgmtController){
@Override public Collection getDependenciesForComponent( String component){
if (component.equals("FAKE_MONITORING_SERVER")) {
Set setOfDependencies=new HashSet();
setOfDependencies.add(yarnClientDependency);
setOfDependencies.add(tezClientDependency);
setOfDependencies.add(mapReduceTwoClientDependency);
setOfDependencies.add(oozieClientDependency);
return setOfDependencies;
}
return Collections.emptySet();
}
/**
* {@inheritDoc}
*/
@Override void registerConditionalDependencies(){
super.registerConditionalDependencies();
Map dependencyConditionalServiceMap=getDependencyConditionalServiceMap();
Collection monitoringDependencies=getDependenciesForComponent("FAKE_MONITORING_SERVER");
for ( DependencyInfo dependency : monitoringDependencies) {
if (dependency.getComponentName().equals("HCAT")) {
dependencyConditionalServiceMap.put(dependency,"HIVE");
}
else if (dependency.getComponentName().equals("OOZIE_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"OOZIE");
}
else if (dependency.getComponentName().equals("YARN_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"YARN");
}
else if (dependency.getComponentName().equals("TEZ_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"TEZ");
}
else if (dependency.getComponentName().equals("MAPREDUCE2_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"MAPREDUCE2");
}
}
}
}
;
assertEquals("Initial conditional dependency map should be empty",0,testStack.getDependencyConditionalServiceMap().size());
testStack.registerConditionalDependencies();
assertEquals("Set of conditional service mappings is an incorrect size",4,testStack.getDependencyConditionalServiceMap().size());
assertEquals("Incorrect service dependency for YARN_CLIENT","YARN",testStack.getDependencyConditionalServiceMap().get(yarnClientDependency));
assertEquals("Incorrect service dependency for TEZ_CLIENT","TEZ",testStack.getDependencyConditionalServiceMap().get(tezClientDependency));
assertEquals("Incorrect service dependency for MAPREDUCE2_CLIENT","MAPREDUCE2",testStack.getDependencyConditionalServiceMap().get(mapReduceTwoClientDependency));
assertEquals("Incorrect service dependency for OOZIE_CLIENT","OOZIE",testStack.getDependencyConditionalServiceMap().get(oozieClientDependency));
mockSupport.verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier emptySet());
expect(mockMgmtController.getStackLevelConfigurations((Set)anyObject())).andReturn(Collections.emptySet()).anyTimes();
final DependencyInfo hCatDependency=new TestDependencyInfo("HIVE/HCAT");
final DependencyInfo yarnClientDependency=new TestDependencyInfo("YARN/YARN_CLIENT");
final DependencyInfo mapReduceTwoClientDependency=new TestDependencyInfo("YARN/MAPREDUCE2_CLIENT");
final DependencyInfo oozieClientDependency=new TestDependencyInfo("OOZIE/OOZIE_CLIENT");
mockSupport.replayAll();
Stack testStack=new Stack("HDP","2.1",mockMgmtController){
@Override public Collection getDependenciesForComponent( String component){
if (component.equals("FAKE_MONITORING_SERVER")) {
Set setOfDependencies=new HashSet();
setOfDependencies.add(hCatDependency);
setOfDependencies.add(yarnClientDependency);
setOfDependencies.add(mapReduceTwoClientDependency);
setOfDependencies.add(oozieClientDependency);
return setOfDependencies;
}
return Collections.emptySet();
}
/**
* {@inheritDoc}
*/
@Override void registerConditionalDependencies(){
super.registerConditionalDependencies();
Map dependencyConditionalServiceMap=getDependencyConditionalServiceMap();
Collection monitoringDependencies=getDependenciesForComponent("FAKE_MONITORING_SERVER");
for ( DependencyInfo dependency : monitoringDependencies) {
if (dependency.getComponentName().equals("HCAT")) {
dependencyConditionalServiceMap.put(dependency,"HIVE");
}
else if (dependency.getComponentName().equals("OOZIE_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"OOZIE");
}
else if (dependency.getComponentName().equals("YARN_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"YARN");
}
else if (dependency.getComponentName().equals("TEZ_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"TEZ");
}
else if (dependency.getComponentName().equals("MAPREDUCE2_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"MAPREDUCE2");
}
}
}
}
;
assertEquals("Initial conditional dependency map should be empty",0,testStack.getDependencyConditionalServiceMap().size());
testStack.registerConditionalDependencies();
assertEquals("Set of conditional service mappings is an incorrect size",4,testStack.getDependencyConditionalServiceMap().size());
assertEquals("Incorrect service dependency for HCAT","HIVE",testStack.getDependencyConditionalServiceMap().get(hCatDependency));
assertEquals("Incorrect service dependency for YARN_CLIENT","YARN",testStack.getDependencyConditionalServiceMap().get(yarnClientDependency));
assertEquals("Incorrect service dependency for MAPREDUCE2_CLIENT","MAPREDUCE2",testStack.getDependencyConditionalServiceMap().get(mapReduceTwoClientDependency));
assertEquals("Incorrect service dependency for OOZIE_CLIENT","OOZIE",testStack.getDependencyConditionalServiceMap().get(oozieClientDependency));
mockSupport.verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier emptySet());
expect(mockMgmtController.getStackLevelConfigurations((Set)anyObject())).andReturn(Collections.emptySet()).anyTimes();
final DependencyInfo hCatDependency=new TestDependencyInfo("HIVE/HCAT");
final DependencyInfo tezClientDependency=new TestDependencyInfo("TEZ/TEZ_CLIENT");
final DependencyInfo mapReduceTwoClientDependency=new TestDependencyInfo("YARN/MAPREDUCE2_CLIENT");
final DependencyInfo oozieClientDependency=new TestDependencyInfo("OOZIE/OOZIE_CLIENT");
mockSupport.replayAll();
Stack testStack=new Stack("HDP","2.1",mockMgmtController){
@Override public Collection getDependenciesForComponent( String component){
if (component.equals("FAKE_MONITORING_SERVER")) {
Set setOfDependencies=new HashSet();
setOfDependencies.add(hCatDependency);
setOfDependencies.add(tezClientDependency);
setOfDependencies.add(mapReduceTwoClientDependency);
setOfDependencies.add(oozieClientDependency);
return setOfDependencies;
}
return Collections.emptySet();
}
/**
* {@inheritDoc}
*/
@Override void registerConditionalDependencies(){
super.registerConditionalDependencies();
Map dependencyConditionalServiceMap=getDependencyConditionalServiceMap();
Collection monitoringDependencies=getDependenciesForComponent("FAKE_MONITORING_SERVER");
for ( DependencyInfo dependency : monitoringDependencies) {
if (dependency.getComponentName().equals("HCAT")) {
dependencyConditionalServiceMap.put(dependency,"HIVE");
}
else if (dependency.getComponentName().equals("OOZIE_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"OOZIE");
}
else if (dependency.getComponentName().equals("YARN_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"YARN");
}
else if (dependency.getComponentName().equals("TEZ_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"TEZ");
}
else if (dependency.getComponentName().equals("MAPREDUCE2_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"MAPREDUCE2");
}
}
}
}
;
assertEquals("Initial conditional dependency map should be empty",0,testStack.getDependencyConditionalServiceMap().size());
testStack.registerConditionalDependencies();
assertEquals("Set of conditional service mappings is an incorrect size",4,testStack.getDependencyConditionalServiceMap().size());
assertEquals("Incorrect service dependency for HCAT","HIVE",testStack.getDependencyConditionalServiceMap().get(hCatDependency));
assertEquals("Incorrect service dependency for TEZ_CLIENT","TEZ",testStack.getDependencyConditionalServiceMap().get(tezClientDependency));
assertEquals("Incorrect service dependency for MAPREDUCE2_CLIENT","MAPREDUCE2",testStack.getDependencyConditionalServiceMap().get(mapReduceTwoClientDependency));
assertEquals("Incorrect service dependency for OOZIE_CLIENT","OOZIE",testStack.getDependencyConditionalServiceMap().get(oozieClientDependency));
mockSupport.verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier emptySet());
expect(mockMgmtController.getStackLevelConfigurations((Set)anyObject())).andReturn(Collections.emptySet()).anyTimes();
final DependencyInfo hCatDependency=new TestDependencyInfo("HIVE/HCAT");
final DependencyInfo yarnClientDependency=new TestDependencyInfo("YARN/YARN_CLIENT");
final DependencyInfo tezClientDependency=new TestDependencyInfo("TEZ/TEZ_CLIENT");
final DependencyInfo mapReduceTwoClientDependency=new TestDependencyInfo("YARN/MAPREDUCE2_CLIENT");
final DependencyInfo oozieClientDependency=new TestDependencyInfo("OOZIE/OOZIE_CLIENT");
mockSupport.replayAll();
Stack testStack=new Stack("HDP","2.1",mockMgmtController){
@Override public Collection getDependenciesForComponent( String component){
if (component.equals("FAKE_MONITORING_SERVER")) {
Set setOfDependencies=new HashSet();
setOfDependencies.add(hCatDependency);
setOfDependencies.add(yarnClientDependency);
setOfDependencies.add(tezClientDependency);
setOfDependencies.add(mapReduceTwoClientDependency);
setOfDependencies.add(oozieClientDependency);
return setOfDependencies;
}
return Collections.emptySet();
}
/**
* {@inheritDoc}
*/
@Override void registerConditionalDependencies(){
super.registerConditionalDependencies();
Map dependencyConditionalServiceMap=getDependencyConditionalServiceMap();
Collection monitoringDependencies=getDependenciesForComponent("FAKE_MONITORING_SERVER");
for ( DependencyInfo dependency : monitoringDependencies) {
if (dependency.getComponentName().equals("HCAT")) {
dependencyConditionalServiceMap.put(dependency,"HIVE");
}
else if (dependency.getComponentName().equals("OOZIE_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"OOZIE");
}
else if (dependency.getComponentName().equals("YARN_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"YARN");
}
else if (dependency.getComponentName().equals("TEZ_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"TEZ");
}
else if (dependency.getComponentName().equals("MAPREDUCE2_CLIENT")) {
dependencyConditionalServiceMap.put(dependency,"MAPREDUCE2");
}
}
}
}
;
assertEquals("Initial conditional dependency map should be empty",0,testStack.getDependencyConditionalServiceMap().size());
testStack.registerConditionalDependencies();
assertEquals("Set of conditional service mappings is an incorrect size",5,testStack.getDependencyConditionalServiceMap().size());
assertEquals("Incorrect service dependency for HCAT","HIVE",testStack.getDependencyConditionalServiceMap().get(hCatDependency));
assertEquals("Incorrect service dependency for YARN_CLIENT","YARN",testStack.getDependencyConditionalServiceMap().get(yarnClientDependency));
assertEquals("Incorrect service dependency for TEZ_CLIENT","TEZ",testStack.getDependencyConditionalServiceMap().get(tezClientDependency));
assertEquals("Incorrect service dependency for MAPREDUCE2_CLIENT","MAPREDUCE2",testStack.getDependencyConditionalServiceMap().get(mapReduceTwoClientDependency));
assertEquals("Incorrect service dependency for OOZIE_CLIENT","OOZIE",testStack.getDependencyConditionalServiceMap().get(oozieClientDependency));
mockSupport.verifyAll();
}
Class: org.apache.ambari.server.controller.internal.BaseProviderTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyIds=new HashSet();
propertyIds.add("foo");
propertyIds.add("bar");
propertyIds.add("cat1/prop1");
propertyIds.add("cat2/prop2");
propertyIds.add("cat3/subcat3/prop3");
propertyIds.add("cat4/subcat4/map");
BaseProvider provider=new TestProvider(propertyIds);
assertTrue(provider.checkPropertyIds(propertyIds).isEmpty());
assertTrue(provider.checkPropertyIds(Collections.singleton("cat1")).isEmpty());
assertTrue(provider.checkPropertyIds(Collections.singleton("cat2")).isEmpty());
assertTrue(provider.checkPropertyIds(Collections.singleton("cat3")).isEmpty());
assertTrue(provider.checkPropertyIds(Collections.singleton("cat3/subcat3")).isEmpty());
assertTrue(provider.checkPropertyIds(Collections.singleton("cat4/subcat4/map")).isEmpty());
assertTrue(provider.checkPropertyIds(Collections.singleton("cat4/subcat4/map/key")).isEmpty());
propertyIds.add("badprop");
propertyIds.add("badcat");
Set unsupportedPropertyIds=provider.checkPropertyIds(propertyIds);
assertFalse(unsupportedPropertyIds.isEmpty());
assertEquals(2,unsupportedPropertyIds.size());
assertTrue(unsupportedPropertyIds.contains("badprop"));
assertTrue(unsupportedPropertyIds.contains("badcat"));
}
InternalCallVerifier BooleanVerifier propertyIds=new HashSet();
propertyIds.add("foo");
propertyIds.add("bar");
propertyIds.add("cat1/prop1");
propertyIds.add("cat2/prop2");
propertyIds.add("cat3/subcat3/prop3");
BaseProvider provider=new TestProvider(propertyIds);
Set supportedPropertyIds=provider.getPropertyIds();
assertTrue(supportedPropertyIds.containsAll(propertyIds));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier providerPropertyIds=new HashSet();
providerPropertyIds.add("foo");
providerPropertyIds.add("bar");
providerPropertyIds.add("cat1/sub1");
BaseProvider provider=new TestProvider(providerPropertyIds);
Request request=PropertyHelper.getReadRequest("foo");
Set requestedPropertyIds=provider.getRequestPropertyIds(request,null);
assertEquals(1,requestedPropertyIds.size());
assertTrue(requestedPropertyIds.contains("foo"));
request=PropertyHelper.getReadRequest("foo","bar");
requestedPropertyIds=provider.getRequestPropertyIds(request,null);
assertEquals(2,requestedPropertyIds.size());
assertTrue(requestedPropertyIds.contains("foo"));
assertTrue(requestedPropertyIds.contains("bar"));
request=PropertyHelper.getReadRequest("foo","baz","bar","cat","cat1/prop1");
requestedPropertyIds=provider.getRequestPropertyIds(request,null);
assertEquals(2,requestedPropertyIds.size());
assertTrue(requestedPropertyIds.contains("foo"));
assertTrue(requestedPropertyIds.contains("bar"));
request=PropertyHelper.getReadRequest("foo","cat1/sub1/prop1");
requestedPropertyIds=provider.getRequestPropertyIds(request,null);
assertEquals(2,requestedPropertyIds.size());
assertTrue(requestedPropertyIds.contains("foo"));
assertTrue(requestedPropertyIds.contains("cat1/sub1/prop1"));
}
InternalCallVerifier EqualityVerifier propertyIds=new HashSet();
propertyIds.add("metrics/flume/$1.substring(0)/CHANNEL/$2.replaceAll(\"[^-]+\",\"\")EventPutSuccessCount/rate/sum");
propertyIds.add("metrics/yarn/Queue/$1.replaceAll(\"([.])\",\"/\")/AppsCompleted");
propertyIds.add("metrics/yarn/Queue/$1.replaceAll(\",q(\\d+)=\",\"/\").substring(1)/AppsFailed");
TestProvider provider=new TestProvider(propertyIds);
Entry entry=provider.getRegexEntry("metrics/flume/flume");
assertEquals("metrics/flume/$1",entry.getKey());
assertEquals("metrics/flume/(\\S*)",entry.getValue().pattern());
entry=provider.getRegexEntry("metrics/flume/flume/CHANNEL");
assertEquals("metrics/flume/$1/CHANNEL",entry.getKey());
assertEquals("metrics/flume/(\\S*)/CHANNEL",entry.getValue().pattern());
entry=provider.getRegexEntry("metrics/flume/flume/CHANNEL/EventPutSuccessCount");
assertEquals("metrics/flume/$1/CHANNEL/$2EventPutSuccessCount",entry.getKey());
assertEquals("metrics/flume/(\\S*)/CHANNEL/(\\S*)EventPutSuccessCount",entry.getValue().pattern());
entry=provider.getRegexEntry("metrics/flume/flume/CHANNEL/EventPutSuccessCount/rate");
assertEquals("metrics/flume/$1/CHANNEL/$2EventPutSuccessCount/rate",entry.getKey());
assertEquals("metrics/flume/(\\S*)/CHANNEL/(\\S*)EventPutSuccessCount/rate",entry.getValue().pattern());
entry=provider.getRegexEntry("metrics/yarn/Queue/root/AppsCompleted");
assertEquals("metrics/yarn/Queue/$1.replaceAll(\"([.])\",\"/\")/AppsCompleted",entry.getKey());
assertEquals("metrics/yarn/Queue/(\\S*)/AppsCompleted",entry.getValue().pattern());
entry=provider.getRegexEntry("metrics/yarn/Queue/root/default/AppsCompleted");
assertEquals("metrics/yarn/Queue/$1.replaceAll(\"([.])\",\"/\")/AppsCompleted",entry.getKey());
assertEquals("metrics/yarn/Queue/(\\S*)/AppsCompleted",entry.getValue().pattern());
entry=provider.getRegexEntry("metrics/yarn/Queue/root/default/AppsFailed");
assertEquals("metrics/yarn/Queue/$1.replaceAll(\",q(\\d+)=\",\"/\").substring(1)/AppsFailed",entry.getKey());
assertEquals("metrics/yarn/Queue/(\\S*)/AppsFailed",entry.getValue().pattern());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier propertyIds=new HashSet();
String regexp="cat/$1.replaceAll(\\\"([.])\\\",\\\"/\\\")/key";
String propertyId="cat/sub/key";
String regexp2="cat/$1.replaceAll(\\\"([.])\\\",\\\"/\\\")/something/$2/key";
String propertyId2="cat/sub/something/sub2/key";
String incorrectPropertyId="some/property/id";
propertyIds.add(regexp);
propertyIds.add(regexp2);
BaseProvider provider=new TestProvider(propertyIds);
Map.Entry regexEntry=provider.getRegexEntry(propertyId);
assertEquals(regexp,regexEntry.getKey());
assertNull(provider.getRegexEntry(incorrectPropertyId));
assertEquals("sub",provider.getRegexGroups(regexp,propertyId).get(0));
assertEquals("sub2",provider.getRegexGroups(regexp2,propertyId2).get(1));
assertTrue(provider.getRegexGroups(regexp,incorrectPropertyId).isEmpty());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier propertyIds=new HashSet();
propertyIds.add("cat1/emptyMapProperty");
propertyIds.add("cat1/mapProperty");
propertyIds.add("cat2/mapMapProperty");
propertyIds.add("cat3/mapProperty3/key2");
propertyIds.add("cat4/mapMapProperty4/subMap1/key3");
propertyIds.add("cat4/mapMapProperty4/subMap2");
Resource resource=new ResourceImpl(Resource.Type.Service);
Map emptyMapProperty=new HashMap();
BaseProvider.setResourceProperty(resource,"cat1/emptyMapProperty",emptyMapProperty,propertyIds);
assertTrue(resource.getPropertiesMap().containsKey("cat1/emptyMapProperty"));
Map mapProperty=new HashMap();
mapProperty.put("key1","value1");
mapProperty.put("key2","value2");
mapProperty.put("key3","value3");
BaseProvider.setResourceProperty(resource,"cat1/mapProperty",mapProperty,propertyIds);
assertNull(resource.getPropertyValue("cat1/mapProperty"));
assertEquals("value1",resource.getPropertyValue("cat1/mapProperty/key1"));
assertEquals("value2",resource.getPropertyValue("cat1/mapProperty/key2"));
assertEquals("value3",resource.getPropertyValue("cat1/mapProperty/key3"));
Map> mapMapProperty=new HashMap>();
Map mapSubProperty1=new HashMap();
mapSubProperty1.put("key1","value11");
mapSubProperty1.put("key2","value12");
mapSubProperty1.put("key3","value13");
mapMapProperty.put("subMap1",mapSubProperty1);
Map mapSubProperty2=new HashMap();
mapSubProperty2.put("key1","value21");
mapSubProperty2.put("key2","value22");
mapSubProperty2.put("key3","value23");
mapMapProperty.put("subMap2",mapSubProperty2);
Map mapSubProperty3=new HashMap();
mapMapProperty.put("subMap3",mapSubProperty3);
BaseProvider.setResourceProperty(resource,"cat2/mapMapProperty",mapMapProperty,propertyIds);
assertNull(resource.getPropertyValue("cat2/mapMapProperty"));
assertNull(resource.getPropertyValue("cat2/mapMapProperty/subMap1"));
assertNull(resource.getPropertyValue("cat2/mapMapProperty/subMap2"));
assertTrue(resource.getPropertiesMap().containsKey("cat2/mapMapProperty/subMap3"));
assertEquals("value11",resource.getPropertyValue("cat2/mapMapProperty/subMap1/key1"));
assertEquals("value12",resource.getPropertyValue("cat2/mapMapProperty/subMap1/key2"));
assertEquals("value13",resource.getPropertyValue("cat2/mapMapProperty/subMap1/key3"));
assertEquals("value21",resource.getPropertyValue("cat2/mapMapProperty/subMap2/key1"));
assertEquals("value22",resource.getPropertyValue("cat2/mapMapProperty/subMap2/key2"));
assertEquals("value23",resource.getPropertyValue("cat2/mapMapProperty/subMap2/key3"));
Map mapProperty3=new HashMap();
mapProperty3.put("key1","value1");
mapProperty3.put("key2","value2");
mapProperty3.put("key3","value3");
BaseProvider.setResourceProperty(resource,"cat3/mapProperty3",mapProperty3,propertyIds);
assertNull(resource.getPropertyValue("cat3/mapProperty3"));
assertNull(resource.getPropertyValue("cat3/mapProperty3/key1"));
assertEquals("value2",resource.getPropertyValue("cat3/mapProperty3/key2"));
assertNull(resource.getPropertyValue("cat3/mapProperty3/key3"));
Map> mapMapProperty4=new HashMap>();
mapMapProperty4.put("subMap1",mapSubProperty1);
mapMapProperty4.put("subMap2",mapSubProperty2);
BaseProvider.setResourceProperty(resource,"cat4/mapMapProperty4",mapMapProperty4,propertyIds);
assertNull(resource.getPropertyValue("cat4/mapMapProperty4"));
assertNull(resource.getPropertyValue("cat4/mapMapProperty4/subMap1"));
assertNull(resource.getPropertyValue("cat4/mapMapProperty4/subMap2"));
assertNull(resource.getPropertyValue("cat4/mapMapProperty4/subMap1/key1"));
assertNull(resource.getPropertyValue("cat4/mapMapProperty4/subMap1/key2"));
assertEquals("value13",resource.getPropertyValue("cat4/mapMapProperty4/subMap1/key3"));
assertEquals("value21",resource.getPropertyValue("cat4/mapMapProperty4/subMap2/key1"));
assertEquals("value22",resource.getPropertyValue("cat4/mapMapProperty4/subMap2/key2"));
assertEquals("value23",resource.getPropertyValue("cat4/mapMapProperty4/subMap2/key3"));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier propertyIds=new HashSet();
propertyIds.add("p1");
propertyIds.add("foo");
propertyIds.add("cat1/foo");
propertyIds.add("cat2/bar");
propertyIds.add("cat2/baz");
propertyIds.add("cat3/sub1/bam");
propertyIds.add("cat4/sub2/sub3/bat");
propertyIds.add("cat5/sub5");
Resource resource=new ResourceImpl(Resource.Type.Service);
assertNull(resource.getPropertyValue("foo"));
BaseProvider.setResourceProperty(resource,"foo","value1",propertyIds);
assertEquals("value1",resource.getPropertyValue("foo"));
BaseProvider.setResourceProperty(resource,"cat2/bar","value2",propertyIds);
assertEquals("value2",resource.getPropertyValue("cat2/bar"));
assertNull(resource.getPropertyValue("unsupported"));
BaseProvider.setResourceProperty(resource,"unsupported","valueX",propertyIds);
assertNull(resource.getPropertyValue("unsupported"));
BaseProvider.setResourceProperty(resource,"cat5/sub5/prop5","value5",propertyIds);
assertEquals("value5",resource.getPropertyValue("cat5/sub5/prop5"));
BaseProvider.setResourceProperty(resource,"cat5/sub5/sub5a/prop5a","value5",propertyIds);
assertEquals("value5",resource.getPropertyValue("cat5/sub5/sub5a/prop5a"));
BaseProvider.setResourceProperty(resource,"cat5/sub7/unsupported","valueX",propertyIds);
assertNull(resource.getPropertyValue("cat5/sub7/unsupported"));
}
Class: org.apache.ambari.server.controller.internal.BlueprintConfigurationProcessorTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("storm.zookeeper.servers","['localhost']");
properties.put("storm-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("ZOOKEEPER_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_SERVER");
Set hosts2=new HashSet();
hosts2.add("testhost2");
hosts2.add("testhost2a");
hosts2.add("testhost2b");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,hosts2);
Collection hgComponents3=new HashSet();
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_CLIENT");
Set hosts3=new HashSet();
hosts3.add("testhost3");
hosts3.add("testhost3a");
TestHostGroup group3=new TestHostGroup("group3",hgComponents3,hosts3);
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
hostGroups.add(group3);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("storm-site").get("storm.zookeeper.servers");
assertTrue(updatedVal.startsWith("["));
assertTrue(updatedVal.endsWith("]"));
updatedVal=updatedVal.replaceAll("[\\[\\]]","");
String[] hosts=updatedVal.split(",");
Collection expectedHosts=new HashSet();
expectedHosts.add("'testhost'");
expectedHosts.add("'testhost2'");
expectedHosts.add("'testhost2a'");
expectedHosts.add("'testhost2b'");
assertEquals(4,hosts.length);
for ( String host : hosts) {
assertTrue(expectedHosts.contains(host));
expectedHosts.remove(host);
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("yarn.resourcemanager.hostname","%HOSTGROUP::group1%");
properties.put("yarn-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("yarn-site").get("yarn.resourcemanager.hostname");
assertEquals("testhost",updatedVal);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map coreSiteMap=new HashMap();
properties.put("core-site",coreSiteMap);
coreSiteMap.put("fs.defaultFS","localhost");
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
expect(stack.getCardinality("NAMENODE")).andReturn(new Cardinality("1")).anyTimes();
Collection hgComponents1=new HashSet();
hgComponents1.add("HIVE_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents1,Collections.singleton("host1"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("host2"));
Collection hostGroups=new ArrayList();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
Collection requiredGroups=updater.getRequiredHostGroups();
assertEquals(0,requiredGroups.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map hiveSiteProps=new HashMap();
hiveSiteProps.put("javax.jdo.option.ConnectionURL","jdbc:mysql://localhost/hive?createDatabaseIfNotExist=true");
Map hiveEnvProps=new HashMap();
hiveEnvProps.put("hive_database","New MySQL Database");
properties.put("hive-site",hiveSiteProps);
properties.put("hive-env",hiveEnvProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
hgComponents.add("MYSQL_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("hive-site").get("javax.jdo.option.ConnectionURL");
assertEquals("jdbc:mysql://testhost/hive?createDatabaseIfNotExist=true",updatedVal);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("yarn.resourcemanager.hostname","%HOSTGROUP::os-amb-r6-secha-1427972156-hbaseha-3-6%:2180");
properties.put("yarn-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("os-amb-r6-secha-1427972156-hbaseha-3-6",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("yarn-site").get("yarn.resourcemanager.hostname");
assertEquals("testhost:2180",updatedVal);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("storm.zookeeper.servers","['%HOSTGROUP::group1%:9090','%HOSTGROUP::group2%:9091']");
typeProps.put("nimbus.seeds","[%HOSTGROUP::group1%, %HOSTGROUP::group4%]");
properties.put("storm-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("ZOOKEEPER_SERVER");
hgComponents.add("NIMBUS");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_SERVER");
hgComponents2.add("NIMBUS");
Set hosts2=new HashSet();
hosts2.add("testhost2");
hosts2.add("testhost2a");
hosts2.add("testhost2b");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,hosts2);
Collection hgComponents3=new HashSet();
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_CLIENT");
Set hosts3=new HashSet();
hosts3.add("testhost3");
hosts3.add("testhost3a");
TestHostGroup group3=new TestHostGroup("group3",hgComponents3,hosts3);
Collection hgComponents4=new HashSet();
hgComponents4.add("NIMBUS");
Set hosts4=new HashSet();
hosts4.add("testhost4");
TestHostGroup group4=new TestHostGroup("group4",hgComponents4,hosts4);
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
hostGroups.add(group3);
hostGroups.add(group4);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("storm-site").get("storm.zookeeper.servers");
assertTrue(updatedVal.startsWith("["));
assertTrue(updatedVal.endsWith("]"));
updatedVal=updatedVal.replaceAll("[\\[\\]]","");
String[] hosts=updatedVal.split(",");
Collection expectedHosts=new HashSet();
expectedHosts.add("'testhost:9090'");
expectedHosts.add("'testhost2:9091'");
expectedHosts.add("'testhost2a:9091'");
expectedHosts.add("'testhost2b:9091'");
assertEquals(4,hosts.length);
for ( String host : hosts) {
assertTrue(expectedHosts.contains(host));
expectedHosts.remove(host);
}
String updatedNimbusSeedsVal=topology.getConfiguration().getFullProperties().get("storm-site").get("nimbus.seeds");
assertTrue("Updated YAML value should start with bracket",updatedNimbusSeedsVal.startsWith("["));
assertTrue("Updated YAML value should end with bracket",updatedNimbusSeedsVal.endsWith("]"));
updatedNimbusSeedsVal=updatedNimbusSeedsVal.replaceAll("[\\[\\]]","");
String[] nimbusHosts=updatedNimbusSeedsVal.split(",");
Collection expectedNimbusHosts=new HashSet();
expectedNimbusHosts.add("testhost");
expectedNimbusHosts.add("testhost4");
assertEquals("Incorrect number of hosts found in updated Nimbus config property",2,nimbusHosts.length);
for ( String host : nimbusHosts) {
assertTrue("Expected Nimbus host = " + host + " not found in nimbus.seeds property value",expectedNimbusHosts.contains(host));
expectedHosts.remove(host);
}
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map atlasProperties=new HashMap();
properties.put("application-properties",atlasProperties);
atlasProperties.put("atlas.enableTLS","false");
atlasProperties.put("atlas.server.bind.address","localhost");
atlasProperties.put("atlas.server.http.port","21000");
Map atlasEnv=new HashMap();
properties.put("atlas-env",atlasEnv);
Map hiveProperties=new HashMap();
hiveProperties.put("hive.exec.post.hooks","");
hiveProperties.put("atlas.cluster.name","primary");
hiveProperties.put("atlas.rest.address","http://localhost:21000");
properties.put("hive-site",hiveProperties);
Map> parentProperties=new HashMap>();
Configuration parentClusterConfig=new Configuration(parentProperties,Collections.>>emptyMap());
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap(),parentClusterConfig);
Collection hgComponents1=new HashSet();
hgComponents1.add("ATLAS_SERVER");
hgComponents1.add("HIVE_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents1,Collections.singleton("host1"));
Collection hostGroups=Collections.singletonList(group1);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor configProcessor=new BlueprintConfigurationProcessor(topology);
configProcessor.doUpdateForClusterCreate();
assertEquals("org.apache.atlas.hive.hook.HiveHook",clusterConfig.getPropertyValue("hive-site","hive.exec.post.hooks"));
assertEquals("1",clusterConfig.getPropertyValue("hive-site","atlas.cluster.name"));
assertEquals("http://host1:21000",clusterConfig.getPropertyValue("hive-site","atlas.rest.address"));
assertEquals("host1",clusterConfig.getPropertyValue("application-properties","atlas.server.bind.address"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("ha.zookeeper.quorum","%HOSTGROUP::os-amb-r6-secha-1427972156-hbaseha-3-6%:2181,%HOSTGROUP::os-amb-r6-secha-1427972156-hbaseha-3-5%:2181,%HOSTGROUP::os-amb-r6-secha-1427972156-hbaseha-3-7%:2181");
properties.put("core-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("ZOOKEEPER_SERVER");
TestHostGroup group1=new TestHostGroup("os-amb-r6-secha-1427972156-hbaseha-3-6",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_SERVER");
Set hosts2=new HashSet();
hosts2.add("testhost2");
hosts2.add("testhost2a");
hosts2.add("testhost2b");
TestHostGroup group2=new TestHostGroup("os-amb-r6-secha-1427972156-hbaseha-3-5",hgComponents2,hosts2);
Collection hgComponents3=new HashSet();
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_CLIENT");
Set hosts3=new HashSet();
hosts3.add("testhost3");
hosts3.add("testhost3a");
TestHostGroup group3=new TestHostGroup("os-amb-r6-secha-1427972156-hbaseha-3-7",hgComponents3,hosts3);
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
hostGroups.add(group3);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("core-site").get("ha.zookeeper.quorum");
String[] hosts=updatedVal.split(",");
Collection expectedHosts=new HashSet();
expectedHosts.add("testhost:2181");
expectedHosts.add("testhost2:2181");
expectedHosts.add("testhost2a:2181");
expectedHosts.add("testhost2b:2181");
expectedHosts.add("testhost3:2181");
expectedHosts.add("testhost3a:2181");
assertEquals(6,hosts.length);
for ( String host : hosts) {
assertTrue("Expected host :" + host + "was not included in the multi-server list in this property.",expectedHosts.contains(host));
expectedHosts.remove(host);
}
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier of("host1:100"));
String updatedValue2=mhtu.resolveHostGroupPlaceholder(propertyOriginalValue2,null,ImmutableList.of("host1:100"));
assertEquals("host1:100",updatedValue1);
assertEquals("host1:100",updatedValue2);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier > configProperties=new HashMap>();
HashMap clusterEnvProperties=new HashMap();
configProperties.put("cluster-env",clusterEnvProperties);
clusterEnvProperties.put("command_retry_enabled","false");
clusterEnvProperties.put("commands_to_retry","TEST");
clusterEnvProperties.put("command_retry_max_time_in_sec","1");
Configuration clusterConfig=new Configuration(configProperties,Collections.>>emptyMap());
TestHostGroup testHostGroup=new TestHostGroup("test-host-group-one",Collections.emptySet(),Collections.emptySet());
ClusterTopology topology=createClusterTopology(bp,clusterConfig,Collections.singleton(testHostGroup));
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
Set updatedConfigTypes=updater.doUpdateForClusterCreate();
assertEquals("Incorrect number of properties added to cluster-env for retry",3,clusterEnvProperties.size());
assertEquals("command_retry_enabled was not set to the expected default","false",clusterEnvProperties.get("command_retry_enabled"));
assertEquals("commands_to_retry was not set to the expected default","TEST",clusterEnvProperties.get("commands_to_retry"));
assertEquals("command_retry_max_time_in_sec was not set to the expected default","1",clusterEnvProperties.get("command_retry_max_time_in_sec"));
assertEquals("Incorrect number of config types updated",0,updatedConfigTypes.size());
}
InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > properties=new HashMap>();
Map coreSiteMap=new HashMap();
properties.put("core-site",coreSiteMap);
coreSiteMap.put("fs.default.name",expectedHostName + ":" + expectedPortNum);
coreSiteMap.put("fs.defaultFS","hdfs://" + expectedHostName + ":"+ expectedPortNum);
coreSiteMap.put("fs.stackDefault.key2","dummyValue");
Map dummySiteMap=new HashMap();
properties.put("dummy-site",dummySiteMap);
dummySiteMap.put("dummy.prop","dummyValue2");
Map> parentProperties=new HashMap>();
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton(expectedHostGroupName));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
Configuration parentConfig=new Configuration(parentProperties,Collections.>>emptyMap(),createStackDefaults());
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap(),parentConfig);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
topology.getAdvisedConfigurations().putAll(createAdvisedConfigMap());
topology.setConfigRecommendationStrategy(ConfigRecommendationStrategy.ONLY_STACK_DEFAULTS_APPLY);
BlueprintConfigurationProcessor configProcessor=new BlueprintConfigurationProcessor(topology);
reset(stack);
expect(stack.getConfiguration(bp.getServices())).andReturn(createStackDefaults()).anyTimes();
replay(stack);
Set configTypeUpdated=configProcessor.doUpdateForClusterCreate();
assertEquals(expectedHostName + ":" + expectedPortNum,clusterConfig.getPropertyValue("core-site","fs.default.name"));
assertEquals("stackDefaultUpgraded",clusterConfig.getPropertyValue("core-site","fs.stackDefault.key1"));
assertNull(clusterConfig.getPropertyValue("core-site","fs.stackDefault.key2"));
assertNull(clusterConfig.getPropertyValue("core-site","fs.notStackDefault"));
assertTrue(configTypeUpdated.contains("dummy-site"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
Map typeProps2=new HashMap();
typeProps.put("yarn.resourcemanager.hostname","localhost");
typeProps2.put("oozie_heapsize","1024");
typeProps2.put("oozie_permsize","128");
properties.put("oozie-env",typeProps2);
properties.put("yarn-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection group1Components=new HashSet();
group1Components.add("NAMENODE");
group1Components.add("SECONDARY_NAMENODE");
group1Components.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",group1Components,Collections.singleton("testhost"));
Collection group2Components=new HashSet();
group2Components.add("DATANODE");
group2Components.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",group2Components,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
Set configTypesUpdated=updater.doUpdateForClusterCreate();
String updatedVal=properties.get("yarn-site").get("yarn.resourcemanager.hostname");
assertEquals("testhost",updatedVal);
String updatedVal1=properties.get("oozie-env").get("oozie_heapsize");
assertEquals("1024m",updatedVal1);
String updatedVal2=properties.get("oozie-env").get("oozie_permsize");
assertEquals("128m",updatedVal2);
assertEquals("Incorrect number of config types updated",3,configTypesUpdated.size());
assertTrue("Expected config type not updated",configTypesUpdated.contains("oozie-env"));
assertTrue("Expected config type not updated",configTypesUpdated.contains("yarn-site"));
assertTrue("Expected config type not updated",configTypesUpdated.contains("cluster-env"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("nimbus.seeds",expectedValue);
properties.put("storm-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NIMBUS");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("NIMBUS");
Set hosts2=new HashSet();
hosts2.add("testhost2");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,hosts2);
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("storm-site").get("nimbus.seeds");
assertEquals("nimbus.seeds property should not be updated when FQDNs are specified in configuration",expectedValue,updatedVal);
}
InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map atlasProperties=new HashMap();
properties.put("application-properties",atlasProperties);
atlasProperties.put("atlas.enableTLS","true");
atlasProperties.put("atlas.server.bind.address","localhost");
atlasProperties.put("atlas.server.https.port","99999");
Map atlasEnv=new HashMap();
properties.put("atlas-env",atlasEnv);
Map hiveProperties=new HashMap();
hiveProperties.put("hive.exec.post.hooks","foo");
hiveProperties.put("atlas.cluster.name","userSpecified");
hiveProperties.put("atlas.rest.address","http://localhost:21000");
properties.put("hive-site",hiveProperties);
Map> parentProperties=new HashMap>();
Configuration parentClusterConfig=new Configuration(parentProperties,Collections.>>emptyMap());
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap(),parentClusterConfig);
Collection hgComponents1=new HashSet();
hgComponents1.add("ATLAS_SERVER");
hgComponents1.add("HIVE_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents1,Collections.singleton("host1"));
Collection hostGroups=Collections.singletonList(group1);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor configProcessor=new BlueprintConfigurationProcessor(topology);
configProcessor.doUpdateForClusterCreate();
assertEquals("foo,org.apache.atlas.hive.hook.HiveHook",clusterConfig.getPropertyValue("hive-site","hive.exec.post.hooks"));
assertEquals("userSpecified",clusterConfig.getPropertyValue("hive-site","atlas.cluster.name"));
assertEquals("https://host1:99999",clusterConfig.getPropertyValue("hive-site","atlas.rest.address"));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > properties=new HashMap>();
Map coreSiteMap=new HashMap();
properties.put("core-site",coreSiteMap);
coreSiteMap.put("fs.default.name",expectedHostName + ":" + expectedPortNum);
coreSiteMap.put("fs.defaultFS","hdfs://" + expectedHostName + ":"+ expectedPortNum);
coreSiteMap.put("fs.stackDefault.key2","dummyValue");
Map> parentProperties=new HashMap>();
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton(expectedHostGroupName));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
Configuration parentClusterConfig=new Configuration(parentProperties,Collections.>>emptyMap(),createStackDefaults());
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap(),parentClusterConfig);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
topology.getAdvisedConfigurations().putAll(createAdvisedConfigMap());
topology.setConfigRecommendationStrategy(ConfigRecommendationStrategy.NEVER_APPLY);
BlueprintConfigurationProcessor configProcessor=new BlueprintConfigurationProcessor(topology);
configProcessor.doUpdateForClusterCreate();
assertEquals(expectedHostName + ":" + expectedPortNum,clusterConfig.getPropertyValue("core-site","fs.default.name"));
assertNull(clusterConfig.getPropertyValue("core-site","fs.notStackDefault"));
assertEquals("stackDefaultValue1",clusterConfig.getPropertyValue("core-site","fs.stackDefault.key1"));
assertNotNull(clusterConfig.getPropertyValue("core-site","fs.stackDefault.key2"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("hbase_master_heapsize","512m");
properties.put("hbase-env",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("hbase-env").get("hbase_master_heapsize");
assertEquals("512m",updatedVal);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("hbase_master_heapsize","512");
properties.put("hbase-env",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("hbase-env").get("hbase_master_heapsize");
assertEquals("512m",updatedVal);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("hbase.zookeeper.quorum","localhost");
properties.put("hbase-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("ZOOKEEPER_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_SERVER");
Set hosts2=new HashSet();
hosts2.add("testhost2");
hosts2.add("testhost2a");
hosts2.add("testhost2b");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,hosts2);
Collection hgComponents3=new HashSet();
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_CLIENT");
Set hosts3=new HashSet();
hosts3.add("testhost3");
hosts3.add("testhost3a");
TestHostGroup group3=new TestHostGroup("group3",hgComponents3,hosts3);
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
hostGroups.add(group3);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("hbase-site").get("hbase.zookeeper.quorum");
String[] hosts=updatedVal.split(",");
Collection expectedHosts=new HashSet();
expectedHosts.add("testhost");
expectedHosts.add("testhost2");
expectedHosts.add("testhost2a");
expectedHosts.add("testhost2b");
assertEquals(4,hosts.length);
for ( String host : hosts) {
assertTrue(expectedHosts.contains(host));
expectedHosts.remove(host);
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("fs.defaultFS","localhost:5050");
properties.put("core-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("core-site").get("fs.defaultFS");
assertEquals("testhost:5050",updatedVal);
}
APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map hdfsSiteProperties=new HashMap();
Map hbaseSiteProperties=new HashMap();
Map hadoopEnvProperties=new HashMap();
Map coreSiteProperties=new HashMap();
Map accumuloSiteProperties=new HashMap();
properties.put("hdfs-site",hdfsSiteProperties);
properties.put("hadoop-env",hadoopEnvProperties);
properties.put("core-site",coreSiteProperties);
properties.put("hbase-site",hbaseSiteProperties);
properties.put("accumulo-site",accumuloSiteProperties);
hdfsSiteProperties.put("dfs.nameservices",expectedNameService);
hdfsSiteProperties.put("dfs.ha.namenodes.mynameservice",expectedNodeOne + ", " + expectedNodeTwo);
hdfsSiteProperties.put("dfs.namenode.https-address." + expectedNameService + "."+ expectedNodeOne,createExportedAddress(expectedPortNum,expectedHostGroupName));
hdfsSiteProperties.put("dfs.namenode.https-address." + expectedNameService + "."+ expectedNodeTwo,createExportedAddress(expectedPortNum,expectedHostGroupName));
hdfsSiteProperties.put("dfs.namenode.http-address." + expectedNameService + "."+ expectedNodeOne,createExportedAddress(expectedPortNum,expectedHostGroupName));
hdfsSiteProperties.put("dfs.namenode.http-address." + expectedNameService + "."+ expectedNodeTwo,createExportedAddress(expectedPortNum,expectedHostGroupName));
hdfsSiteProperties.put("dfs.namenode.rpc-address." + expectedNameService + "."+ expectedNodeOne,createExportedAddress(expectedPortNum,expectedHostGroupName));
hdfsSiteProperties.put("dfs.namenode.rpc-address." + expectedNameService + "."+ expectedNodeTwo,createExportedAddress(expectedPortNum,expectedHostGroupName));
hdfsSiteProperties.put("dfs.secondary.http.address","localhost:8080");
hdfsSiteProperties.put("dfs.namenode.secondary.http-address","localhost:8080");
hdfsSiteProperties.put("dfs.namenode.http-address","localhost:8080");
hdfsSiteProperties.put("dfs.namenode.https-address","localhost:8081");
hdfsSiteProperties.put("dfs.namenode.rpc-address","localhost:8082");
coreSiteProperties.put("fs.defaultFS","hdfs://" + expectedNameService);
hbaseSiteProperties.put("hbase.rootdir","hdfs://" + expectedNameService + "/hbase/test/root/dir");
accumuloSiteProperties.put("instance.volumes","hdfs://" + expectedNameService + "/accumulo/test/instance/volumes");
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
TestHostGroup group1=new TestHostGroup(expectedHostGroupName,hgComponents,Collections.singleton(expectedHostName));
Collection hgComponents2=new HashSet();
hgComponents2.add("NAMENODE");
TestHostGroup group2=new TestHostGroup("host-group-2",hgComponents2,Collections.singleton(expectedHostNameTwo));
Collection hostGroups=new ArrayList();
hostGroups.add(group1);
hostGroups.add(group2);
expect(stack.getCardinality("NAMENODE")).andReturn(new Cardinality("1-2")).anyTimes();
expect(stack.getCardinality("SECONDARY_NAMENODE")).andReturn(new Cardinality("1")).anyTimes();
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
Set updatedConfigTypes=updater.doUpdateForClusterCreate();
assertEquals("HTTPS address HA property not properly exported",expectedHostName + ":" + expectedPortNum,hdfsSiteProperties.get("dfs.namenode.https-address." + expectedNameService + "."+ expectedNodeOne));
assertEquals("HTTPS address HA property not properly exported",expectedHostName + ":" + expectedPortNum,hdfsSiteProperties.get("dfs.namenode.https-address." + expectedNameService + "."+ expectedNodeTwo));
assertEquals("HTTPS address HA property not properly exported",expectedHostName + ":" + expectedPortNum,hdfsSiteProperties.get("dfs.namenode.http-address." + expectedNameService + "."+ expectedNodeOne));
assertEquals("HTTPS address HA property not properly exported",expectedHostName + ":" + expectedPortNum,hdfsSiteProperties.get("dfs.namenode.http-address." + expectedNameService + "."+ expectedNodeTwo));
assertEquals("HTTPS address HA property not properly exported",expectedHostName + ":" + expectedPortNum,hdfsSiteProperties.get("dfs.namenode.rpc-address." + expectedNameService + "."+ expectedNodeOne));
assertEquals("HTTPS address HA property not properly exported",expectedHostName + ":" + expectedPortNum,hdfsSiteProperties.get("dfs.namenode.rpc-address." + expectedNameService + "."+ expectedNodeTwo));
String initialActiveHost=hadoopEnvProperties.get("dfs_ha_initial_namenode_active");
String expectedStandbyHost=null;
if (initialActiveHost.equals(expectedHostName)) {
expectedStandbyHost=expectedHostNameTwo;
}
else if (initialActiveHost.equals(expectedHostNameTwo)) {
expectedStandbyHost=expectedHostName;
}
else {
fail("Active Namenode hostname was not set correctly");
}
assertEquals("Standby Namenode hostname was not set correctly",expectedStandbyHost,hadoopEnvProperties.get("dfs_ha_initial_namenode_standby"));
assertEquals("fs.defaultFS should not be modified by cluster update when NameNode HA is enabled.","hdfs://" + expectedNameService,coreSiteProperties.get("fs.defaultFS"));
assertEquals("hbase.rootdir should not be modified by cluster update when NameNode HA is enabled.","hdfs://" + expectedNameService + "/hbase/test/root/dir",hbaseSiteProperties.get("hbase.rootdir"));
assertEquals("instance.volumes should not be modified by cluster update when NameNode HA is enabled.","hdfs://" + expectedNameService + "/accumulo/test/instance/volumes",accumuloSiteProperties.get("instance.volumes"));
assertFalse("dfs.namenode.http-address should have been filtered out of this HA configuration",hdfsSiteProperties.containsKey("dfs.namenode.http-address"));
assertFalse("dfs.namenode.https-address should have been filtered out of this HA configuration",hdfsSiteProperties.containsKey("dfs.namenode.https-address"));
assertFalse("dfs.namenode.rpc-address should have been filtered out of this HA configuration",hdfsSiteProperties.containsKey("dfs.namenode.rpc-address"));
assertEquals("Incorrect number of updated config types returned, set = " + updatedConfigTypes,3,updatedConfigTypes.size());
assertTrue("Expected config type not found in updated set",updatedConfigTypes.contains("cluster-env"));
assertTrue("Expected config type not found in updated set",updatedConfigTypes.contains("hdfs-site"));
assertTrue("Expected config type not found in updated set",updatedConfigTypes.contains("hadoop-env"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("yarn.timeline-service.address",expectedHostName);
properties.put("yarn-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection group1Components=new HashSet();
group1Components.add("NAMENODE");
group1Components.add("SECONDARY_NAMENODE");
group1Components.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",group1Components,Collections.singleton("testhost"));
Collection group2Components=new HashSet();
group2Components.add("DATANODE");
group2Components.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",group2Components,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
expect(stack.getCardinality("APP_TIMELINE_SERVER")).andReturn(new Cardinality("0-1")).anyTimes();
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("yarn-site").get("yarn.timeline-service.address");
assertEquals("Timeline Server config property should not have been updated",expectedHostName,updatedVal);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("javax.jdo.option.ConnectionURL","jdbc:mysql://myHost.com/hive?createDatabaseIfNotExist=true");
typeProps.put("hive_database","Existing MySQL Database");
properties.put("hive-env",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("hive-env").get("javax.jdo.option.ConnectionURL");
assertEquals("jdbc:mysql://myHost.com/hive?createDatabaseIfNotExist=true",updatedVal);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map hdfsSiteProperties=new HashMap();
Map hbaseSiteProperties=new HashMap();
Map hadoopEnvProperties=new HashMap();
Map coreSiteProperties=new HashMap();
Map accumuloSiteProperties=new HashMap();
properties.put("hdfs-site",hdfsSiteProperties);
properties.put("hadoop-env",hadoopEnvProperties);
properties.put("core-site",coreSiteProperties);
properties.put("hbase-site",hbaseSiteProperties);
properties.put("accumulo-site",accumuloSiteProperties);
hdfsSiteProperties.put("dfs.secondary.http.address","localhost:8080");
hdfsSiteProperties.put("dfs.namenode.secondary.http-address","localhost:8080");
hdfsSiteProperties.put("dfs.namenode.http-address","localhost:8080");
hdfsSiteProperties.put("dfs.namenode.https-address","localhost:8081");
hdfsSiteProperties.put("dfs.namenode.rpc-address","localhost:8082");
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
TestHostGroup group1=new TestHostGroup(expectedHostGroupName,hgComponents,Collections.singleton(expectedHostName));
Collection hgComponents2=new HashSet();
TestHostGroup group2=new TestHostGroup("host-group-2",hgComponents2,Collections.singleton(expectedHostNameTwo));
Collection hostGroups=new ArrayList();
hostGroups.add(group1);
hostGroups.add(group2);
expect(stack.getCardinality("NAMENODE")).andReturn(new Cardinality("1-2")).anyTimes();
expect(stack.getCardinality("SECONDARY_NAMENODE")).andReturn(new Cardinality("1")).anyTimes();
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
Set updatedConfigTypes=updater.doUpdateForClusterCreate();
assertTrue("dfs.namenode.http-address should have been included in this HA configuration",hdfsSiteProperties.containsKey("dfs.namenode.http-address"));
assertTrue("dfs.namenode.https-address should have been included in this HA configuration",hdfsSiteProperties.containsKey("dfs.namenode.https-address"));
assertTrue("dfs.namenode.rpc-address should have been included in this HA configuration",hdfsSiteProperties.containsKey("dfs.namenode.rpc-address"));
assertEquals("Incorrect number of updated config types returned, set = " + updatedConfigTypes,2,updatedConfigTypes.size());
assertTrue("Expected config type 'cluster-env' not found in updated set",updatedConfigTypes.contains("cluster-env"));
assertTrue("Expected config type 'hdfs-site' not found in updated set",updatedConfigTypes.contains("hdfs-site"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("nimbus.seeds","localhost");
properties.put("storm-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NIMBUS");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("NIMBUS");
Set hosts2=new HashSet();
hosts2.add("testhost2");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,hosts2);
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("storm-site").get("nimbus.seeds");
assertTrue("Updated YAML value should start with bracket",updatedVal.startsWith("["));
assertTrue("Updated YAML value should end with bracket",updatedVal.endsWith("]"));
updatedVal=updatedVal.replaceAll("[\\[\\]]","");
String[] hosts=updatedVal.split(",");
Collection expectedHosts=new HashSet();
expectedHosts.add("testhost");
expectedHosts.add("testhost2");
assertEquals("Incorrect number of hosts found in updated Nimbus config property",2,hosts.length);
for ( String host : hosts) {
assertTrue("Expected host name = " + host + " not found in updated Nimbus config property",expectedHosts.contains(host));
expectedHosts.remove(host);
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("templeton.zookeeper.hosts","%HOSTGROUP::group1%:9090,%HOSTGROUP::group2%:9091");
properties.put("webhcat-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("ZOOKEEPER_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_SERVER");
Set hosts2=new HashSet();
hosts2.add("testhost2");
hosts2.add("testhost2a");
hosts2.add("testhost2b");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,hosts2);
Collection hgComponents3=new HashSet();
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_CLIENT");
Set hosts3=new HashSet();
hosts3.add("testhost3");
hosts3.add("testhost3a");
TestHostGroup group3=new TestHostGroup("group3",hgComponents3,hosts3);
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
hostGroups.add(group3);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("webhcat-site").get("templeton.zookeeper.hosts");
String[] hosts=updatedVal.split(",");
Collection expectedHosts=new HashSet();
expectedHosts.add("testhost:9090");
expectedHosts.add("testhost2:9091");
expectedHosts.add("testhost2a:9091");
expectedHosts.add("testhost2b:9091");
assertEquals(4,hosts.length);
for ( String host : hosts) {
assertTrue(expectedHosts.contains(host));
expectedHosts.remove(host);
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("templeton.zookeeper.hosts","localhost:9090");
properties.put("webhcat-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("ZOOKEEPER_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_SERVER");
Set hosts2=new HashSet();
hosts2.add("testhost2");
hosts2.add("testhost2a");
hosts2.add("testhost2b");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,hosts2);
Collection hgComponents3=new HashSet();
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_CLIENT");
Set hosts3=new HashSet();
hosts3.add("testhost3");
hosts3.add("testhost3a");
TestHostGroup group3=new TestHostGroup("group3",hgComponents3,hosts3);
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
hostGroups.add(group3);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("webhcat-site").get("templeton.zookeeper.hosts");
String[] hosts=updatedVal.split(",");
Collection expectedHosts=new HashSet();
expectedHosts.add("testhost:9090");
expectedHosts.add("testhost2:9090");
expectedHosts.add("testhost2a:9090");
expectedHosts.add("testhost2b:9090");
assertEquals(4,hosts.length);
for ( String host : hosts) {
assertTrue(expectedHosts.contains(host));
expectedHosts.remove(host);
}
}
InternalCallVerifier EqualityVerifier of("host1:100","host2:200"));
assertEquals("http://host1:100,host2:200/resource",updatedValue);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > properties=new HashMap>();
Map coreSiteMap=new HashMap();
properties.put("core-site",coreSiteMap);
coreSiteMap.put("fs.default.name",expectedHostName + ":" + expectedPortNum);
coreSiteMap.put("fs.defaultFS","hdfs://" + expectedHostName + ":"+ expectedPortNum);
coreSiteMap.put("fs.stackDefault.key2","dummyValue");
Map dummySiteMap=new HashMap();
properties.put("dummy-site",dummySiteMap);
dummySiteMap.put("dummy.prop","dummyValue");
Map> parentProperties=new HashMap>();
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton(expectedHostGroupName));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
Configuration parentClusterConfig=new Configuration(parentProperties,Collections.>>emptyMap(),createStackDefaults());
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap(),parentClusterConfig);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
topology.getAdvisedConfigurations().putAll(createAdvisedConfigMap());
topology.setConfigRecommendationStrategy(ConfigRecommendationStrategy.ALWAYS_APPLY);
BlueprintConfigurationProcessor configProcessor=new BlueprintConfigurationProcessor(topology);
Set configTypes=configProcessor.doUpdateForClusterCreate();
assertEquals(expectedHostName + ":" + expectedPortNum,clusterConfig.getPropertyValue("core-site","fs.default.name"));
assertEquals("stackDefaultUpgraded",clusterConfig.getPropertyValue("core-site","fs.stackDefault.key1"));
assertNull(clusterConfig.getPropertyValue("core-site","fs.stackDefault.key2"));
assertNotNull(clusterConfig.getPropertyValue("core-site","fs.notStackDefault"));
assertEquals(2,topology.getAdvisedConfigurations().size());
assertFalse(configTypes.contains("dummy-site"));
}
InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > configProperties=new HashMap>();
HashMap clusterEnvProperties=new HashMap();
configProperties.put("cluster-env",clusterEnvProperties);
Configuration clusterConfig=new Configuration(configProperties,Collections.>>emptyMap());
TestHostGroup testHostGroup=new TestHostGroup("test-host-group-one",Collections.emptySet(),Collections.emptySet());
ClusterTopology topology=createClusterTopology(bp,clusterConfig,Collections.singleton(testHostGroup));
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
Set updatedConfigTypes=updater.doUpdateForClusterCreate();
assertEquals("Incorrect number of properties added to cluster-env for retry",3,clusterEnvProperties.size());
assertEquals("command_retry_enabled was not set to the expected default","true",clusterEnvProperties.get("command_retry_enabled"));
assertEquals("commands_to_retry was not set to the expected default","INSTALL,START",clusterEnvProperties.get("commands_to_retry"));
assertEquals("command_retry_max_time_in_sec was not set to the expected default","600",clusterEnvProperties.get("command_retry_max_time_in_sec"));
assertEquals("Incorrect number of config types updated by this operation",1,updatedConfigTypes.size());
assertTrue("Expected type not included in the updated set",updatedConfigTypes.contains("cluster-env"));
}
InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("yarn.timeline-service.address","testhost:10200");
typeProps.put("yarn.timeline-service.webapp.address","testhost:8188");
typeProps.put("yarn.timeline-service.webapp.https.address","testhost:8190");
properties.put("yarn-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection group1Components=new HashSet();
group1Components.add("NAMENODE");
group1Components.add("SECONDARY_NAMENODE");
group1Components.add("RESOURCEMANAGER");
group1Components.add("APP_TIMELINE_SERVER");
TestHostGroup group1=new TestHostGroup("group1",group1Components,Collections.singleton("testhost"));
Collection group2Components=new HashSet();
group2Components.add("DATANODE");
group2Components.add("HDFS_CLIENT");
group2Components.add("APP_TIMELINE_SERVER");
TestHostGroup group2=new TestHostGroup("group2",group2Components,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
expect(stack.getCardinality("APP_TIMELINE_SERVER")).andReturn(new Cardinality("0-1")).anyTimes();
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("yarn-site").get("yarn.timeline-service.address");
assertEquals("Timeline Server config property should not have been updated","testhost:10200",updatedVal);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map hiveSiteProps=new HashMap();
hiveSiteProps.put("javax.jdo.option.ConnectionURL","jdbc:mysql://%HOSTGROUP::group1%/hive?createDatabaseIfNotExist=true");
Map hiveEnvProps=new HashMap();
hiveEnvProps.put("hive_database","New MySQL Database");
properties.put("hive-site",hiveSiteProps);
properties.put("hive-env",hiveEnvProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
hgComponents.add("MYSQL_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("hive-site").get("javax.jdo.option.ConnectionURL");
assertEquals("jdbc:mysql://testhost/hive?createDatabaseIfNotExist=true",updatedVal);
}
InternalCallVerifier EqualityVerifier of("host1:100","host2:200"));
String updatedValue2=mhtu.resolveHostGroupPlaceholder(propertyOriginalValue2,null,ImmutableList.of("host1:100","host2:200"));
assertEquals("host1:100,host2:200",updatedValue1);
assertEquals("host1:100,host2:200",updatedValue2);
}
InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map kmsSiteProperties=new HashMap();
properties.put(kmsSiteConfigType,kmsSiteProperties);
kmsSiteProperties.put("hadoop.kms.authentication.signer.secret.provider.zookeeper.connection.string",createHostAddress("%HOSTGROUP::group1%","2181") + "," + createHostAddress("%HOSTGROUP::group2%","2181"));
kmsSiteProperties.put("hadoop.kms.key.provider.uri","dbks://http@localhost:9292/kms");
Map> parentProperties=new HashMap>();
Configuration parentClusterConfig=new Configuration(parentProperties,Collections.>>emptyMap());
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap(),parentClusterConfig);
Collection kmsServerComponents=new HashSet();
kmsServerComponents.add("RANGER_KMS_SERVER");
TestHostGroup group1=new TestHostGroup("group1",kmsServerComponents,Collections.singleton("host1"));
TestHostGroup group2=new TestHostGroup("group2",kmsServerComponents,Collections.singleton("host2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor configProcessor=new BlueprintConfigurationProcessor(topology);
configProcessor.doUpdateForClusterCreate();
assertEquals("host1:2181,host2:2181",clusterConfig.getPropertyValue(kmsSiteConfigType,"hadoop.kms.authentication.signer.secret.provider.zookeeper.connection.string"));
assertEquals("dbks://http@localhost:9292/kms",clusterConfig.getPropertyValue(kmsSiteConfigType,"hadoop.kms.key.provider.uri"));
}
InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map yarnSiteProps=new HashMap();
yarnSiteProps.put("yarn.resourcemanager.hostname","testhost");
properties.put("yarn-site",yarnSiteProps);
Map> parentProperties=new HashMap>();
Map parentYarnSiteProps=new HashMap();
parentYarnSiteProps.put("yarn.resourcemanager.resource-tracker.address","testhost");
parentProperties.put("yarn-site",parentYarnSiteProps);
Configuration parentClusterConfig=new Configuration(parentProperties,Collections.>>emptyMap());
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap(),parentClusterConfig);
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor configProcessor=new BlueprintConfigurationProcessor(topology);
configProcessor.doUpdateForBlueprintExport();
assertEquals("%HOSTGROUP::group1%",clusterConfig.getPropertyValue("yarn-site","yarn.resourcemanager.hostname"));
assertEquals("%HOSTGROUP::group1%",clusterConfig.getPropertyValue("yarn-site","yarn.resourcemanager.resource-tracker.address"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map coreSiteMap=new HashMap();
properties.put("core-site",coreSiteMap);
coreSiteMap.put("fs.defaultFS","localhost");
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
expect(stack.getCardinality("NAMENODE")).andReturn(new Cardinality("1")).anyTimes();
Collection hgComponents1=new HashSet();
hgComponents1.add("HIVE_SERVER");
hgComponents1.add("NAMENODE");
TestHostGroup group1=new TestHostGroup("group1",hgComponents1,Collections.singleton("host1"));
Collection hgComponents2=new HashSet();
hgComponents2.add("NAMENODE");
hgComponents2.add("DATANODE");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("host2"));
Collection hostGroups=new ArrayList();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
Collection requiredGroups=updater.getRequiredHostGroups();
assertEquals(2,requiredGroups.size());
assertTrue(requiredGroups.containsAll(Arrays.asList("group1","group2")));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("yarn.resourcemanager.hostname","%HOSTGROUP::os-amb-r6-secha-1427972156-hbaseha-3-6%");
properties.put("yarn-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("os-amb-r6-secha-1427972156-hbaseha-3-6",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("yarn-site").get("yarn.resourcemanager.hostname");
assertEquals("testhost",updatedVal);
}
InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map yarnSiteProps=new HashMap();
yarnSiteProps.put("yarn.resourcemanager.hostname","localhost");
properties.put("yarn-site",yarnSiteProps);
Map> parentProperties=new HashMap>();
Map parentYarnSiteProps=new HashMap();
parentYarnSiteProps.put("yarn.resourcemanager.resource-tracker.address","localhost");
parentProperties.put("yarn-site",parentYarnSiteProps);
Configuration parentClusterConfig=new Configuration(parentProperties,Collections.>>emptyMap());
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap(),parentClusterConfig);
Collection group1Components=new HashSet();
group1Components.add("NAMENODE");
group1Components.add("SECONDARY_NAMENODE");
group1Components.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",group1Components,Collections.singleton("testhost"));
Collection group2Components=new HashSet();
group2Components.add("DATANODE");
group2Components.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",group2Components,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
assertEquals("testhost",clusterConfig.getPropertyValue("yarn-site","yarn.resourcemanager.hostname"));
assertEquals("testhost",clusterConfig.getPropertyValue("yarn-site","yarn.resourcemanager.resource-tracker.address"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("fs.defaultFS","%HOSTGROUP::group1%:5050");
properties.put("core-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("RESOURCEMANAGER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("testhost2"));
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("core-site").get("fs.defaultFS");
assertEquals("testhost:5050",updatedVal);
}
InternalCallVerifier EqualityVerifier of("host1:100"));
assertEquals("http://host1:100#",updatedValue);
}
InternalCallVerifier EqualityVerifier of("host1:100","host2:200"));
assertEquals("host1:100,host2:200",updatedValue);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > properties=new HashMap>();
Map typeProps=new HashMap();
typeProps.put("hbase.zookeeper.quorum","%HOSTGROUP::group1%,%HOSTGROUP::group2%");
properties.put("hbase-site",typeProps);
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents=new HashSet();
hgComponents.add("NAMENODE");
hgComponents.add("SECONDARY_NAMENODE");
hgComponents.add("ZOOKEEPER_SERVER");
TestHostGroup group1=new TestHostGroup("group1",hgComponents,Collections.singleton("testhost"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_SERVER");
Set hosts2=new HashSet();
hosts2.add("testhost2");
hosts2.add("testhost2a");
hosts2.add("testhost2b");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,hosts2);
Collection hgComponents3=new HashSet();
hgComponents2.add("HDFS_CLIENT");
hgComponents2.add("ZOOKEEPER_CLIENT");
Set hosts3=new HashSet();
hosts3.add("testhost3");
hosts3.add("testhost3a");
TestHostGroup group3=new TestHostGroup("group3",hgComponents3,hosts3);
Collection hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
hostGroups.add(group3);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
updater.doUpdateForClusterCreate();
String updatedVal=topology.getConfiguration().getFullProperties().get("hbase-site").get("hbase.zookeeper.quorum");
String[] hosts=updatedVal.split(",");
Collection expectedHosts=new HashSet();
expectedHosts.add("testhost");
expectedHosts.add("testhost2");
expectedHosts.add("testhost2a");
expectedHosts.add("testhost2b");
assertEquals(4,hosts.length);
for ( String host : hosts) {
assertTrue(expectedHosts.contains(host));
expectedHosts.remove(host);
}
}
InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map hiveSite=new HashMap();
properties.put("hive-site",hiveSite);
Map hiveEnv=new HashMap();
properties.put("hive-env",hiveEnv);
hiveSite.put("javax.jdo.option.ConnectionURL","localhost:1111");
hiveEnv.put("hive_database","New Database");
Configuration clusterConfig=new Configuration(properties,Collections.>>emptyMap());
Collection hgComponents1=new HashSet();
hgComponents1.add("HIVE_SERVER");
hgComponents1.add("NAMENODE");
TestHostGroup group1=new TestHostGroup("group1",hgComponents1,Collections.singleton("host1"));
Collection hgComponents2=new HashSet();
hgComponents2.add("DATANODE");
TestHostGroup group2=new TestHostGroup("group2",hgComponents2,Collections.singleton("host2"));
Collection hostGroups=new ArrayList();
hostGroups.add(group1);
hostGroups.add(group2);
ClusterTopology topology=createClusterTopology(bp,clusterConfig,hostGroups);
BlueprintConfigurationProcessor updater=new BlueprintConfigurationProcessor(topology);
Collection requiredGroups=updater.getRequiredHostGroups();
assertEquals(0,requiredGroups.size());
}
Class: org.apache.ambari.server.controller.internal.BlueprintResourceProviderTest InternalCallVerifier NullVerifier configuration=null;
BlueprintConfiguration config=new BlueprintConfigEntity();
provider.populateConfigurationEntity(configuration,config);
assertNotNull(config.getConfigAttributes());
assertNotNull(config.getConfigData());
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier configMap=new HashMap();
configMap.put("global/hive_database","db");
BlueprintConfigPopulationStrategy provisioner=provider.decidePopulationStrategy(configMap);
assertNotNull(provisioner);
assertTrue(provisioner instanceof BlueprintConfigPopulationStrategyV1);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > setProperties=getBlueprintTestProperties();
setConfigurationProperties(setProperties);
AmbariManagementController managementController=createMock(AmbariManagementController.class);
Map requestInfoProperties=new HashMap();
requestInfoProperties.put(Request.REQUEST_INFO_BODY_PROPERTY,"{\"configurations\":[]}");
Request request=createMock(Request.class);
expect(blueprintFactory.createBlueprint(setProperties.iterator().next(),null)).andReturn(blueprint).once();
blueprint.validateRequiredProperties();
blueprint.validateTopology();
expect(blueprint.toEntity()).andReturn(entity);
expect(blueprint.getName()).andReturn(BLUEPRINT_NAME).atLeastOnce();
expect(request.getProperties()).andReturn(setProperties);
expect(request.getRequestInfoProperties()).andReturn(requestInfoProperties);
expect(dao.findByName(BLUEPRINT_NAME)).andReturn(null);
dao.create(entity);
replay(dao,entity,metaInfo,blueprintFactory,blueprint,request,managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(Resource.Type.Blueprint,PropertyHelper.getPropertyIds(Resource.Type.Blueprint),PropertyHelper.getKeyPropertyIds(Resource.Type.Blueprint),managementController);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
((ObservableResourceProvider)provider).addObserver(observer);
provider.createResources(request);
ResourceProviderEvent lastEvent=observer.getLastEvent();
assertNotNull(lastEvent);
assertEquals(Resource.Type.Blueprint,lastEvent.getResourceType());
assertEquals(ResourceProviderEvent.Type.Create,lastEvent.getType());
assertEquals(request,lastEvent.getRequest());
assertNull(lastEvent.getPredicate());
verify(dao,entity,blueprintFactory,metaInfo,request,managementController);
}
InternalCallVerifier EqualityVerifier >()).anyTimes();
expect(metaInfo.getStack("test-stack-name","test-stack-version")).andReturn(info).anyTimes();
replay(info,metaInfo);
Request request=createNiceMock(Request.class);
Set> testProperties=getBlueprintTestProperties();
setConfigurationProperties(testProperties);
BlueprintEntity entity=createEntity(testProperties.iterator().next());
List results=new ArrayList();
results.add(entity);
expect(dao.findAll()).andReturn(results);
replay(dao,request);
Set setResults=provider.getResources(request,null);
assertEquals(1,setResults.size());
verify(dao);
validateResource(setResults.iterator().next(),true);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > setProperties=getBlueprintTestProperties();
setConfigurationProperties(setProperties);
AmbariManagementController managementController=createMock(AmbariManagementController.class);
Map requestInfoProperties=getTestRequestInfoProperties();
Request request=createMock(Request.class);
expect(blueprintFactory.createBlueprint(setProperties.iterator().next(),null)).andReturn(blueprint).once();
blueprint.validateRequiredProperties();
blueprint.validateTopology();
expect(blueprint.toEntity()).andReturn(entity);
expect(blueprint.getName()).andReturn(BLUEPRINT_NAME).atLeastOnce();
expect(request.getProperties()).andReturn(setProperties);
expect(request.getRequestInfoProperties()).andReturn(requestInfoProperties);
expect(dao.findByName(BLUEPRINT_NAME)).andReturn(null);
dao.create(entity);
replay(dao,entity,metaInfo,blueprintFactory,blueprint,request,managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(Resource.Type.Blueprint,PropertyHelper.getPropertyIds(Resource.Type.Blueprint),PropertyHelper.getKeyPropertyIds(Resource.Type.Blueprint),managementController);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
((ObservableResourceProvider)provider).addObserver(observer);
provider.createResources(request);
ResourceProviderEvent lastEvent=observer.getLastEvent();
assertNotNull(lastEvent);
assertEquals(Resource.Type.Blueprint,lastEvent.getResourceType());
assertEquals(ResourceProviderEvent.Type.Create,lastEvent.getType());
assertEquals(request,lastEvent.getRequest());
assertNull(lastEvent.getPredicate());
verify(dao,entity,blueprintFactory,metaInfo,request,managementController);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier configuration=new HashMap();
configuration.put("global/property1","val1");
configuration.put("global/property2","val2");
BlueprintConfiguration config=new BlueprintConfigEntity();
provider.populateConfigurationEntity(configuration,config);
assertNotNull(config.getConfigData());
assertNotNull(config.getConfigAttributes());
Map configData=StageUtils.getGson().fromJson(config.getConfigData(),Map.class);
Map> configAttrs=StageUtils.getGson().fromJson(config.getConfigAttributes(),Map.class);
assertNotNull(configData);
assertNotNull(configAttrs);
assertEquals(2,configData.size());
assertTrue(configData.containsKey("property1"));
assertTrue(configData.containsKey("property2"));
assertEquals("val1",configData.get("property1"));
assertEquals("val2",configData.get("property2"));
assertEquals(0,configAttrs.size());
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier configMap=new HashMap();
BlueprintConfigPopulationStrategy provisioner=provider.decidePopulationStrategy(configMap);
assertNotNull(provisioner);
assertTrue(provisioner instanceof BlueprintConfigPopulationStrategyV2);
}
InternalCallVerifier EqualityVerifier results=new ArrayList();
results.add(entity);
expect(dao.findAll()).andReturn(results);
replay(dao,request);
Set setResults=provider.getResources(request,null);
assertEquals(1,setResults.size());
verify(dao);
validateResource(setResults.iterator().next(),false);
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier configMap=null;
BlueprintConfigPopulationStrategy provisioner=provider.decidePopulationStrategy(configMap);
assertNotNull(provisioner);
assertTrue(provisioner instanceof BlueprintConfigPopulationStrategyV2);
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier configMap=new HashMap();
configMap.put("global/properties_attributes/final/foo_contact","true");
BlueprintConfigPopulationStrategy provisioner=provider.decidePopulationStrategy(configMap);
assertNotNull(provisioner);
assertTrue(provisioner instanceof BlueprintConfigPopulationStrategyV2);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > setProperties=getBlueprintTestProperties();
setConfigurationProperties(setProperties);
AmbariManagementController managementController=createMock(AmbariManagementController.class);
Map requestInfoProperties=new HashMap();
requestInfoProperties.put(Request.REQUEST_INFO_BODY_PROPERTY,"{\"configurations\":[{\"configuration-type\":{\"properties\":{\"property\":\"value\"}}}]}");
Request request=createMock(Request.class);
expect(blueprintFactory.createBlueprint(setProperties.iterator().next(),null)).andReturn(blueprint).once();
blueprint.validateRequiredProperties();
blueprint.validateTopology();
expect(blueprint.toEntity()).andReturn(entity);
expect(blueprint.getName()).andReturn(BLUEPRINT_NAME).atLeastOnce();
expect(request.getProperties()).andReturn(setProperties);
expect(request.getRequestInfoProperties()).andReturn(requestInfoProperties);
expect(dao.findByName(BLUEPRINT_NAME)).andReturn(null);
dao.create(entity);
replay(dao,entity,metaInfo,blueprintFactory,blueprint,request,managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(Resource.Type.Blueprint,PropertyHelper.getPropertyIds(Resource.Type.Blueprint),PropertyHelper.getKeyPropertyIds(Resource.Type.Blueprint),managementController);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
((ObservableResourceProvider)provider).addObserver(observer);
provider.createResources(request);
ResourceProviderEvent lastEvent=observer.getLastEvent();
assertNotNull(lastEvent);
assertEquals(Resource.Type.Blueprint,lastEvent.getResourceType());
assertEquals(ResourceProviderEvent.Type.Create,lastEvent.getType());
assertEquals(request,lastEvent.getRequest());
assertNull(lastEvent.getPredicate());
verify(dao,entity,blueprintFactory,metaInfo,request,managementController);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > pwdProperties=new HashMap>(){
{
put(PropertyInfo.PropertyType.PASSWORD,new HashSet(){
{
add("test.password");
}
}
);
}
}
;
StackInfo info=createMock(StackInfo.class);
expect(info.getConfigPropertiesTypes("type1")).andReturn(new HashMap>()).anyTimes();
expect(info.getConfigPropertiesTypes("type2")).andReturn(new HashMap>()).anyTimes();
expect(info.getConfigPropertiesTypes("type3")).andReturn(pwdProperties).anyTimes();
expect(metaInfo.getStack("test-stack-name","test-stack-version")).andReturn(info).anyTimes();
replay(info,metaInfo,entity);
BlueprintConfigEntity config1=new BlueprintConfigEntity();
config1.setType("type1");
config1.setConfigData("{\"key1\":\"value1\"}");
config1.setBlueprintEntity(entity);
BlueprintConfigEntity config2=new BlueprintConfigEntity();
config2.setType("type2");
config2.setConfigData("{\"key2\":\"value2\"}");
config2.setConfigAttributes("{}");
config2.setBlueprintEntity(entity);
BlueprintConfigEntity config3=new BlueprintConfigEntity();
config3.setType("type3");
config3.setConfigData("{\"key3\":\"value3\",\"key4\":\"value4\",\"test.password\":\"pwdValue\"}");
config3.setConfigAttributes("{\"final\":{\"key3\":\"attrValue1\",\"key4\":\"attrValue2\"}}");
config3.setBlueprintEntity(entity);
List>> configs=provider.populateConfigurationList(Arrays.asList(config1,config2,config3));
assertNotNull(configs);
assertEquals(3,configs.size());
Map> configuration1=configs.get(0);
assertNotNull(configuration1);
assertEquals(1,configuration1.size());
assertTrue(configuration1.containsKey("type1"));
Map typeConfig1=configuration1.get("type1");
assertNotNull(typeConfig1);
assertEquals(1,typeConfig1.size());
assertTrue(typeConfig1.containsKey(BlueprintResourceProvider.PROPERTIES_PROPERTY_ID));
Map confProperties1=(Map)typeConfig1.get(BlueprintResourceProvider.PROPERTIES_PROPERTY_ID);
assertNotNull(confProperties1);
assertEquals(1,confProperties1.size());
assertEquals("value1",confProperties1.get("key1"));
Map> configuration2=configs.get(1);
assertNotNull(configuration2);
assertEquals(1,configuration2.size());
assertTrue(configuration2.containsKey("type2"));
Map typeConfig2=configuration2.get("type2");
assertNotNull(typeConfig2);
assertEquals(1,typeConfig2.size());
assertTrue(typeConfig2.containsKey(BlueprintResourceProvider.PROPERTIES_PROPERTY_ID));
Map confProperties2=(Map)typeConfig2.get(BlueprintResourceProvider.PROPERTIES_PROPERTY_ID);
assertNotNull(confProperties2);
assertEquals(1,confProperties2.size());
assertEquals("value2",confProperties2.get("key2"));
Map> configuration3=configs.get(2);
assertNotNull(configuration3);
assertEquals(1,configuration3.size());
assertTrue(configuration3.containsKey("type3"));
Map typeConfig3=configuration3.get("type3");
assertNotNull(typeConfig3);
assertEquals(2,typeConfig3.size());
assertTrue(typeConfig3.containsKey(BlueprintResourceProvider.PROPERTIES_PROPERTY_ID));
Map confProperties3=(Map)typeConfig3.get(BlueprintResourceProvider.PROPERTIES_PROPERTY_ID);
assertNotNull(confProperties3);
assertEquals(3,confProperties3.size());
assertEquals("value3",confProperties3.get("key3"));
assertEquals("value4",confProperties3.get("key4"));
assertEquals("SECRET:type3:-1:test.password",confProperties3.get("test.password"));
assertTrue(typeConfig3.containsKey(BlueprintResourceProvider.PROPERTIES_ATTRIBUTES_PROPERTY_ID));
Map> confAttributes3=(Map>)typeConfig3.get(BlueprintResourceProvider.PROPERTIES_ATTRIBUTES_PROPERTY_ID);
assertNotNull(confAttributes3);
assertEquals(1,confAttributes3.size());
assertTrue(confAttributes3.containsKey("final"));
Map finalAttrs=confAttributes3.get("final");
assertEquals(2,finalAttrs.size());
assertEquals("attrValue1",finalAttrs.get("key3"));
assertEquals("attrValue2",finalAttrs.get("key4"));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > setProperties=getBlueprintTestProperties();
Map requestInfoProperties=getTestRequestInfoProperties();
SecurityConfiguration securityConfiguration=new SecurityConfiguration(SecurityType.KERBEROS,"testRef",null);
expect(securityFactory.createSecurityConfigurationFromRequest(anyObject(HashMap.class),anyBoolean())).andReturn(securityConfiguration).once();
expect(blueprintFactory.createBlueprint(setProperties.iterator().next(),securityConfiguration)).andReturn(blueprint).once();
blueprint.validateRequiredProperties();
blueprint.validateTopology();
expect(blueprint.toEntity()).andReturn(entity);
expect(blueprint.getName()).andReturn(BLUEPRINT_NAME).atLeastOnce();
expect(request.getProperties()).andReturn(setProperties);
expect(request.getRequestInfoProperties()).andReturn(requestInfoProperties);
expect(dao.findByName(BLUEPRINT_NAME)).andReturn(null);
dao.create(entity);
replay(dao,entity,metaInfo,blueprintFactory,securityFactory,blueprint,request,managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(Resource.Type.Blueprint,PropertyHelper.getPropertyIds(Resource.Type.Blueprint),PropertyHelper.getKeyPropertyIds(Resource.Type.Blueprint),managementController);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
((ObservableResourceProvider)provider).addObserver(observer);
provider.createResources(request);
ResourceProviderEvent lastEvent=observer.getLastEvent();
assertNotNull(lastEvent);
assertEquals(Resource.Type.Blueprint,lastEvent.getResourceType());
assertEquals(ResourceProviderEvent.Type.Create,lastEvent.getType());
assertEquals(request,lastEvent.getRequest());
assertNull(lastEvent.getPredicate());
verify(dao,entity,blueprintFactory,metaInfo,request,managementController);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > setProperties=getBlueprintTestProperties();
Map requestInfoProperties=getTestRequestInfoProperties();
requestInfoProperties.put("validate_topology","false");
expect(blueprintFactory.createBlueprint(setProperties.iterator().next(),null)).andReturn(blueprint).once();
blueprint.validateRequiredProperties();
expect(blueprint.toEntity()).andReturn(entity);
expect(blueprint.getName()).andReturn(BLUEPRINT_NAME).atLeastOnce();
expect(request.getProperties()).andReturn(setProperties);
expect(request.getRequestInfoProperties()).andReturn(requestInfoProperties);
expect(dao.findByName(BLUEPRINT_NAME)).andReturn(null);
dao.create(entity);
replay(dao,entity,metaInfo,blueprintFactory,blueprint,request,managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(Resource.Type.Blueprint,PropertyHelper.getPropertyIds(Resource.Type.Blueprint),PropertyHelper.getKeyPropertyIds(Resource.Type.Blueprint),managementController);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
((ObservableResourceProvider)provider).addObserver(observer);
provider.createResources(request);
ResourceProviderEvent lastEvent=observer.getLastEvent();
assertNotNull(lastEvent);
assertEquals(Resource.Type.Blueprint,lastEvent.getResourceType());
assertEquals(ResourceProviderEvent.Type.Create,lastEvent.getType());
assertEquals(request,lastEvent.getRequest());
assertNull(lastEvent.getPredicate());
verify(dao,entity,blueprintFactory,metaInfo,request,managementController);
}
InternalCallVerifier NullVerifier configuration=new HashMap();
BlueprintConfiguration config=new BlueprintConfigEntity();
provider.populateConfigurationEntity(configuration,config);
assertNotNull(config.getConfigAttributes());
assertNotNull(config.getConfigData());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier configuration=new HashMap();
configuration.put("global/properties/property1","val1");
configuration.put("global/properties/property2","val2");
configuration.put("global/properties_attributes/final/property1","true");
configuration.put("global/properties_attributes/final/property2","false");
configuration.put("global/properties_attributes/deletable/property1","true");
BlueprintConfiguration config=new BlueprintConfigEntity();
provider.populateConfigurationEntity(configuration,config);
assertNotNull(config.getConfigData());
assertNotNull(config.getConfigAttributes());
Map configData=StageUtils.getGson().fromJson(config.getConfigData(),Map.class);
Map> configAttrs=StageUtils.getGson().fromJson(config.getConfigAttributes(),Map.class);
assertNotNull(configData);
assertNotNull(configAttrs);
assertEquals(2,configData.size());
assertTrue(configData.containsKey("property1"));
assertTrue(configData.containsKey("property2"));
assertEquals("val1",configData.get("property1"));
assertEquals("val2",configData.get("property2"));
assertEquals(2,configAttrs.size());
assertTrue(configAttrs.containsKey("final"));
assertTrue(configAttrs.containsKey("deletable"));
Map finalAttrs=configAttrs.get("final");
assertNotNull(finalAttrs);
assertEquals(2,finalAttrs.size());
assertTrue(finalAttrs.containsKey("property1"));
assertTrue(finalAttrs.containsKey("property2"));
assertEquals("true",finalAttrs.get("property1"));
assertEquals("false",finalAttrs.get("property2"));
Map deletableAttrs=configAttrs.get("deletable");
assertNotNull(deletableAttrs);
assertEquals(1,deletableAttrs.size());
assertTrue(deletableAttrs.containsKey("property1"));
assertEquals("true",deletableAttrs.get("property1"));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > setProperties=getBlueprintTestProperties();
Map requestInfoProperties=getTestRequestInfoProperties();
expect(blueprintFactory.createBlueprint(setProperties.iterator().next(),null)).andReturn(blueprint).once();
expect(securityFactory.createSecurityConfigurationFromRequest(null,true)).andReturn(null).anyTimes();
blueprint.validateRequiredProperties();
blueprint.validateTopology();
expect(blueprint.toEntity()).andReturn(entity);
expect(blueprint.getName()).andReturn(BLUEPRINT_NAME).atLeastOnce();
expect(request.getProperties()).andReturn(setProperties);
expect(request.getRequestInfoProperties()).andReturn(requestInfoProperties);
expect(dao.findByName(BLUEPRINT_NAME)).andReturn(null);
dao.create(entity);
replay(dao,entity,metaInfo,blueprintFactory,securityFactory,blueprint,request,managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(Resource.Type.Blueprint,PropertyHelper.getPropertyIds(Resource.Type.Blueprint),PropertyHelper.getKeyPropertyIds(Resource.Type.Blueprint),managementController);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
((ObservableResourceProvider)provider).addObserver(observer);
provider.createResources(request);
ResourceProviderEvent lastEvent=observer.getLastEvent();
assertNotNull(lastEvent);
assertEquals(Resource.Type.Blueprint,lastEvent.getResourceType());
assertEquals(ResourceProviderEvent.Type.Create,lastEvent.getType());
assertEquals(request,lastEvent.getRequest());
assertNull(lastEvent.getPredicate());
verify(dao,entity,blueprintFactory,securityFactory,metaInfo,request,managementController);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (BlueprintResourceProvider.BLUEPRINT_NAME_PROPERTY_ID,BLUEPRINT_NAME);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
provider.addObserver(observer);
provider.deleteResources(predicate);
ResourceProviderEvent lastEvent=observer.getLastEvent();
assertNotNull(lastEvent);
assertEquals(Resource.Type.Blueprint,lastEvent.getResourceType());
assertEquals(ResourceProviderEvent.Type.Delete,lastEvent.getType());
assertNotNull(lastEvent.getPredicate());
verify(dao);
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier configMap=new HashMap();
configMap.put("global/properties/foo_contact","foo@ffl.dsfds");
BlueprintConfigPopulationStrategy provisioner=provider.decidePopulationStrategy(configMap);
assertNotNull(provisioner);
assertTrue(provisioner instanceof BlueprintConfigPopulationStrategyV2);
}
Class: org.apache.ambari.server.controller.internal.CalculatedStatusTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier stages;
CalculatedStatus status;
stages=getStages(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED));
status=CalculatedStatus.statusFromStages(stages);
assertEquals(HostRoleStatus.COMPLETED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
stages=getStages(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.IN_PROGRESS,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStages(stages);
assertEquals(HostRoleStatus.IN_PROGRESS,status.getStatus());
assertEquals(48.3,status.getPercent(),0.1);
stages=getStages(getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStages(stages);
assertEquals(HostRoleStatus.PENDING,status.getStatus());
assertEquals(0.0,status.getPercent(),0.1);
stages=getStages(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.FAILED,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStages(stages);
assertEquals(HostRoleStatus.FAILED,status.getStatus());
assertEquals(55.55,status.getPercent(),0.1);
stages=getStages(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.TIMEDOUT),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStages(stages);
assertEquals(HostRoleStatus.TIMEDOUT,status.getStatus());
assertEquals(66.66,status.getPercent(),0.1);
stages=getStages(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.HOLDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStages(stages);
assertEquals(HostRoleStatus.HOLDING,status.getStatus());
assertEquals(47.5,status.getPercent(),0.1);
stages=getStages(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.HOLDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStages(stages);
assertEquals(HostRoleStatus.HOLDING,status.getStatus());
assertEquals(47.5,status.getPercent(),0.1);
stages=getStages(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.HOLDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStages(stages);
assertEquals(HostRoleStatus.HOLDING,status.getStatus());
assertNull(status.getDisplayStatus());
assertEquals(47.5,status.getPercent(),0.1);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier stages=getStageEntities(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED));
CalculatedStatus status=CalculatedStatus.statusFromStageEntities(stages);
assertEquals(HostRoleStatus.COMPLETED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
stages=getStageEntities(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.IN_PROGRESS,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStageEntities(stages);
assertEquals(HostRoleStatus.IN_PROGRESS,status.getStatus());
assertEquals(48.3,status.getPercent(),0.1);
stages=getStageEntities(getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStageEntities(stages);
assertEquals(HostRoleStatus.PENDING,status.getStatus());
assertEquals(0.0,status.getPercent(),0.1);
stages=getStageEntities(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.FAILED,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStageEntities(stages);
assertEquals(HostRoleStatus.FAILED,status.getStatus());
assertEquals(55.55,status.getPercent(),0.1);
stages=getStageEntities(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.TIMEDOUT),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStageEntities(stages);
assertEquals(HostRoleStatus.TIMEDOUT,status.getStatus());
assertEquals(66.66,status.getPercent(),0.1);
stages=getStageEntities(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.HOLDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStageEntities(stages);
assertEquals(HostRoleStatus.HOLDING,status.getStatus());
assertEquals(47.5,status.getPercent(),0.1);
stages=getStageEntities(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.HOLDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStageEntities(stages);
assertEquals(HostRoleStatus.HOLDING,status.getStatus());
assertEquals(47.5,status.getPercent(),0.1);
stages=getStageEntities(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED),getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.HOLDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING),getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING));
status=CalculatedStatus.statusFromStageEntities(stages);
assertEquals(HostRoleStatus.HOLDING,status.getStatus());
assertEquals(47.5,status.getPercent(),0.1);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier tasks=getTaskEntities(HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING);
CalculatedStatus status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.PENDING,status.getStatus());
assertEquals(0.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.FAILED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED);
status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.FAILED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.FAILED,HostRoleStatus.FAILED);
status=CalculatedStatus.statusFromTaskEntities(tasks,true);
assertEquals(HostRoleStatus.COMPLETED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.TIMEDOUT,HostRoleStatus.TIMEDOUT,HostRoleStatus.TIMEDOUT,HostRoleStatus.TIMEDOUT);
status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.TIMEDOUT,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.TIMEDOUT,HostRoleStatus.FAILED,HostRoleStatus.TIMEDOUT,HostRoleStatus.TIMEDOUT);
status=CalculatedStatus.statusFromTaskEntities(tasks,true);
assertEquals(HostRoleStatus.COMPLETED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED);
status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.ABORTED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED,HostRoleStatus.ABORTED);
status=CalculatedStatus.statusFromTaskEntities(tasks,true);
assertEquals(HostRoleStatus.ABORTED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.PENDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING);
status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.IN_PROGRESS,status.getStatus());
assertEquals(40.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED);
status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.COMPLETED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.HOLDING,HostRoleStatus.PENDING,HostRoleStatus.PENDING);
status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.HOLDING,status.getStatus());
assertEquals(54.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.HOLDING_FAILED,HostRoleStatus.PENDING,HostRoleStatus.PENDING);
status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.HOLDING_FAILED,status.getStatus());
assertEquals(54.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.HOLDING_TIMEDOUT,HostRoleStatus.PENDING,HostRoleStatus.PENDING);
status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.HOLDING_TIMEDOUT,status.getStatus());
assertEquals(54.0,status.getPercent(),0.1);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier tasks=getTaskEntities(HostRoleStatus.ABORTED);
CalculatedStatus status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.ABORTED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
status=CalculatedStatus.statusFromTaskEntities(tasks,true);
assertEquals(HostRoleStatus.ABORTED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
tasks=getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.ABORTED);
status=CalculatedStatus.statusFromTaskEntities(tasks,false);
assertEquals(HostRoleStatus.ABORTED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
status=CalculatedStatus.statusFromTaskEntities(tasks,true);
assertEquals(HostRoleStatus.ABORTED,status.getStatus());
assertEquals(100.0,status.getPercent(),0.1);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier stages=new ArrayList();
stages.addAll(getStages(getTaskEntities(HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED,HostRoleStatus.COMPLETED)));
HostRoleCommandEntity entity=new HostRoleCommandEntity();
entity.setTaskId(taskId++);
entity.setStatus(HostRoleStatus.PENDING);
stages.addAll(getStages(Collections.singleton(entity)));
CalculatedStatus calc=CalculatedStatus.statusFromStages(stages);
assertEquals(HostRoleStatus.IN_PROGRESS,calc.getStatus());
assertEquals(80d,calc.getPercent(),0.1d);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier taskStatuses1=new ArrayList(){
{
add(HostRoleStatus.COMPLETED);
add(HostRoleStatus.COMPLETED);
add(HostRoleStatus.COMPLETED);
}
}
;
final HostRoleCommandStatusSummaryDTO summary2=createNiceMock(HostRoleCommandStatusSummaryDTO.class);
ArrayList taskStatuses2=new ArrayList(){
{
add(HostRoleStatus.COMPLETED);
add(HostRoleStatus.SKIPPED_FAILED);
add(HostRoleStatus.COMPLETED);
}
}
;
Map stageDto=new HashMap(){
{
put(1l,summary1);
put(2l,summary2);
}
}
;
Set stageIds=new HashSet(){
{
add(1l);
add(2l);
}
}
;
expect(summary1.getTaskTotal()).andReturn(taskStatuses1.size()).anyTimes();
expect(summary2.getTaskTotal()).andReturn(taskStatuses2.size()).anyTimes();
expect(summary1.isStageSkippable()).andReturn(true).anyTimes();
expect(summary2.isStageSkippable()).andReturn(true).anyTimes();
expect(summary1.getTaskStatuses()).andReturn(taskStatuses1).anyTimes();
expect(summary2.getTaskStatuses()).andReturn(taskStatuses2).anyTimes();
replay(summary1,summary2);
CalculatedStatus calc=CalculatedStatus.statusFromStageSummary(stageDto,stageIds);
assertEquals(HostRoleStatus.SKIPPED_FAILED,calc.getDisplayStatus());
assertEquals(HostRoleStatus.COMPLETED,calc.getStatus());
}
Class: org.apache.ambari.server.controller.internal.ClientConfigResourceProviderTest APIUtilityVerifier InternalCallVerifier BooleanVerifier configMap=createNiceMock(Map.class);
File mockFile=PowerMock.createNiceMock(File.class);
Runtime runtime=createMock(Runtime.class);
Process process=createNiceMock(Process.class);
Map desiredConfigMap=new HashMap();
desiredConfigMap.put("hive-site",desiredConfig);
Map> allConfigTags=new HashMap>();
Map> properties=new HashMap>();
Map> configTags=new HashMap>();
Map>> attributes=new HashMap>>();
ClientConfigFileDefinition clientConfigFileDefinition=new ClientConfigFileDefinition();
clientConfigFileDefinition.setDictionaryName("pig-env");
clientConfigFileDefinition.setFileName("pig-env.sh");
clientConfigFileDefinition.setType("env");
List clientConfigFileDefinitionList=new LinkedList();
clientConfigFileDefinitionList.add(clientConfigFileDefinition);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Request request=PropertyHelper.getReadRequest(ClientConfigResourceProvider.COMPONENT_CLUSTER_NAME_PROPERTY_ID,"c1",ClientConfigResourceProvider.COMPONENT_COMPONENT_NAME_PROPERTY_ID,ClientConfigResourceProvider.COMPONENT_SERVICE_NAME_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(ClientConfigResourceProvider.COMPONENT_CLUSTER_NAME_PROPERTY_ID).equals("c1").toPredicate();
String clusterName="C1";
String serviceName="PIG";
String componentName="PIG";
String hostName="Host100";
String desiredState="INSTALLED";
String stackName="S1";
String stackVersion="V1";
String stackRoot="/tmp/stacks/S1/V1";
String packageFolder=StackManager.COMMON_SERVICES + "/PIG/package";
String commonServicesPath="/var/lib/ambari-server/src/main/resources" + File.separator + "common-services";
if (System.getProperty("os.name").contains("Windows")) {
stackRoot="C:\\tmp\\stacks\\S1\\V1";
packageFolder=StackManager.COMMON_SERVICES + "\\PIG\\package";
}
HashMap hosts=new HashMap();
hosts.put(hostName,host);
HashMap services=new HashMap();
services.put(serviceName,service);
HashMap serviceComponentMap=new HashMap();
serviceComponentMap.put(componentName,serviceComponent);
HashMap serviceComponentHosts=new HashMap();
serviceComponentHosts.put(componentName,serviceComponentHost);
HashMap serviceOsSpecificHashMap=new HashMap();
serviceOsSpecificHashMap.put("key",serviceOsSpecific);
ServiceComponentHostResponse shr1=new ServiceComponentHostResponse(clusterName,serviceName,componentName,hostName,desiredState,"",null,null,null);
Set responses=new LinkedHashSet();
responses.add(shr1);
Map returnConfigMap=new HashMap();
returnConfigMap.put(Configuration.SERVER_TMP_DIR_KEY,Configuration.SERVER_TMP_DIR_DEFAULT);
returnConfigMap.put(Configuration.AMBARI_PYTHON_WRAP_KEY,Configuration.AMBARI_PYTHON_WRAP_DEFAULT);
expect(managementController.getConfigHelper()).andReturn(configHelper);
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster(clusterName)).andReturn(cluster).anyTimes();
expect(configHelper.getEffectiveConfigProperties(cluster,configTags)).andReturn(properties);
expect(clusterConfig.getType()).andReturn(Configuration.HIVE_CONFIG_TAG).anyTimes();
expect(configHelper.getEffectiveConfigAttributes(cluster,configTags)).andReturn(attributes);
expect(configMap.get(Configuration.SERVER_TMP_DIR_KEY)).andReturn(Configuration.SERVER_TMP_DIR_DEFAULT);
expect(configMap.get(Configuration.AMBARI_PYTHON_WRAP_KEY)).andReturn(Configuration.AMBARI_PYTHON_WRAP_DEFAULT);
expect(configuration.getConfigsMap()).andReturn(returnConfigMap);
expect(configuration.getResourceDirPath()).andReturn("/var/lib/ambari-server/src/main/resources");
expect(configuration.getJavaVersion()).andReturn(8);
expect(configuration.areHostsSysPrepped()).andReturn("false");
expect(configuration.getExternalScriptTimeout()).andReturn(Integer.parseInt(Configuration.EXTERNAL_SCRIPT_TIMEOUT_DEFAULT));
Map props=new HashMap();
props.put(Configuration.HIVE_METASTORE_PASSWORD_PROPERTY,"pass");
props.put("key","value");
expect(clusterConfig.getProperties()).andReturn(props);
expect(configHelper.getEffectiveDesiredTags(cluster,hostName)).andReturn(allConfigTags);
expect(cluster.getClusterName()).andReturn(clusterName);
expect(managementController.getHostComponents((Set)anyObject())).andReturn(responses).anyTimes();
expect(cluster.getCurrentStackVersion()).andReturn(stackId);
PowerMock.mockStaticPartial(StageUtils.class,"getClusterHostInfo");
Map> clusterHostInfo=new HashMap>();
Set all_hosts=new HashSet(Arrays.asList("Host100","Host101","Host102"));
Set some_hosts=new HashSet(Arrays.asList("0-1","2"));
Set ohter_hosts=new HashSet(Arrays.asList("0,1"));
Set clusterHostTypes=new HashSet(Arrays.asList("nm_hosts","hs_host","namenode_host","rm_host","snamenode_host","slave_hosts","zookeeper_hosts"));
for ( String hostTypes : clusterHostTypes) {
if (hostTypes.equals("slave_hosts")) {
clusterHostInfo.put(hostTypes,ohter_hosts);
}
else {
clusterHostInfo.put(hostTypes,some_hosts);
}
}
Map stringHostMap=new HashMap();
stringHostMap.put(hostName,host);
clusterHostInfo.put("all_hosts",all_hosts);
expect(StageUtils.getClusterHostInfo(cluster)).andReturn(clusterHostInfo);
expect(stackId.getStackName()).andReturn(stackName).anyTimes();
expect(stackId.getStackVersion()).andReturn(stackVersion).anyTimes();
expect(ambariMetaInfo.getComponent(stackName,stackVersion,serviceName,componentName)).andReturn(componentInfo);
expect(ambariMetaInfo.getService(stackName,stackVersion,serviceName)).andReturn(serviceInfo);
expect(serviceInfo.getServicePackageFolder()).andReturn(packageFolder);
expect(ambariMetaInfo.getComponent((String)anyObject(),(String)anyObject(),(String)anyObject(),(String)anyObject())).andReturn(componentInfo).anyTimes();
expect(componentInfo.getCommandScript()).andReturn(commandScriptDefinition);
expect(componentInfo.getClientConfigFiles()).andReturn(clientConfigFileDefinitionList);
expect(cluster.getConfig("hive-site",null)).andReturn(clusterConfig);
expect(cluster.getDesiredConfigs()).andReturn(desiredConfigMap);
expect(clusters.getHost(hostName)).andReturn(host);
HashMap rcaParams=new HashMap();
rcaParams.put("key","value");
expect(managementController.getRcaParameters()).andReturn(rcaParams).anyTimes();
expect(ambariMetaInfo.getService(stackName,stackVersion,serviceName)).andReturn(serviceInfo);
expect(serviceInfo.getOsSpecifics()).andReturn(new HashMap()).anyTimes();
Set userSet=new HashSet();
userSet.add("hdfs");
expect(configHelper.getPropertyValuesWithPropertyType(stackId,PropertyInfo.PropertyType.USER,cluster)).andReturn(userSet);
PowerMock.expectNew(File.class,new Class[]{String.class},anyObject(String.class)).andReturn(mockFile).anyTimes();
PowerMock.createNiceMockAndExpectNew(PrintWriter.class,anyObject());
expect(mockFile.getParent()).andReturn("");
PowerMock.mockStatic(Runtime.class);
expect(mockFile.exists()).andReturn(true);
String commandLine="ambari-python-wrap " + commonServicesPath + "/PIG/package/null generate_configs null "+ commonServicesPath+ "/PIG/package /var/lib/ambari-server/tmp/structured-out.json "+ "INFO /var/lib/ambari-server/tmp";
if (System.getProperty("os.name").contains("Windows")) {
commandLine="ambari-python-wrap " + commonServicesPath + "\\PIG\\package\\null generate_configs null "+ commonServicesPath+ "\\PIG\\package /var/lib/ambari-server/tmp\\structured-out.json "+ "INFO /var/lib/ambari-server/tmp";
}
ProcessBuilder processBuilder=PowerMock.createNiceMock(ProcessBuilder.class);
PowerMock.expectNew(ProcessBuilder.class,Arrays.asList(commandLine.split("\\s+"))).andReturn(processBuilder).once();
expect(processBuilder.start()).andReturn(process).once();
InputStream inputStream=new ByteArrayInputStream("some logging info".getBytes());
expect(process.getInputStream()).andReturn(inputStream);
replay(managementController,clusters,cluster,ambariMetaInfo,stackId,componentInfo,commandScriptDefinition,clusterConfig,host,service,serviceComponent,serviceComponentHost,serviceInfo,configHelper,runtime,process,configMap);
PowerMock.replayAll();
Set resources=provider.getResources(request,predicate);
assertFalse(resources.isEmpty());
verify(managementController,clusters,cluster,ambariMetaInfo,stackId,componentInfo,commandScriptDefinition,clusterConfig,host,service,serviceComponent,serviceComponentHost,serviceInfo,configHelper,runtime,process);
PowerMock.verifyAll();
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier configMap=createNiceMock(Map.class);
File mockFile=PowerMock.createNiceMock(File.class);
Runtime runtime=createMock(Runtime.class);
Process process=createNiceMock(Process.class);
Map desiredConfigMap=new HashMap();
desiredConfigMap.put("hive-site",desiredConfig);
Map> allConfigTags=new HashMap>();
Map> properties=new HashMap>();
Map> configTags=new HashMap>();
Map>> attributes=new HashMap>>();
ClientConfigFileDefinition clientConfigFileDefinition=new ClientConfigFileDefinition();
clientConfigFileDefinition.setDictionaryName("pig-env");
clientConfigFileDefinition.setFileName("pig-env.sh");
clientConfigFileDefinition.setType("env");
List clientConfigFileDefinitionList=new LinkedList();
clientConfigFileDefinitionList.add(clientConfigFileDefinition);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Request request=PropertyHelper.getReadRequest(ClientConfigResourceProvider.COMPONENT_CLUSTER_NAME_PROPERTY_ID,"c1",ClientConfigResourceProvider.COMPONENT_COMPONENT_NAME_PROPERTY_ID,ClientConfigResourceProvider.COMPONENT_SERVICE_NAME_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(ClientConfigResourceProvider.COMPONENT_CLUSTER_NAME_PROPERTY_ID).equals("c1").toPredicate();
String clusterName="C1";
String serviceName="PIG";
String componentName="PIG";
String hostName="Host100";
String desiredState="INSTALLED";
String stackName="S1";
String stackVersion="V1";
String stackRoot="/tmp/stacks/S1/V1";
String packageFolder="PIG/package";
if (System.getProperty("os.name").contains("Windows")) {
stackRoot="C:\\tmp\\stacks\\S1\\V1";
packageFolder="PIG\\package";
}
HashMap hosts=new HashMap();
hosts.put(hostName,host);
HashMap services=new HashMap();
services.put(serviceName,service);
HashMap serviceComponentMap=new HashMap();
serviceComponentMap.put(componentName,serviceComponent);
HashMap serviceComponentHosts=new HashMap();
serviceComponentHosts.put(componentName,serviceComponentHost);
HashMap serviceOsSpecificHashMap=new HashMap();
serviceOsSpecificHashMap.put("key",serviceOsSpecific);
ServiceComponentHostResponse shr1=new ServiceComponentHostResponse(clusterName,serviceName,componentName,hostName,desiredState,"",null,null,null);
Set responses=new LinkedHashSet();
responses.add(shr1);
Map returnConfigMap=new HashMap();
returnConfigMap.put(Configuration.SERVER_TMP_DIR_KEY,Configuration.SERVER_TMP_DIR_DEFAULT);
returnConfigMap.put(Configuration.AMBARI_PYTHON_WRAP_KEY,Configuration.AMBARI_PYTHON_WRAP_DEFAULT);
expect(managementController.getConfigHelper()).andReturn(configHelper);
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster(clusterName)).andReturn(cluster).anyTimes();
expect(configHelper.getEffectiveConfigProperties(cluster,configTags)).andReturn(properties);
expect(clusterConfig.getType()).andReturn(Configuration.HIVE_CONFIG_TAG).anyTimes();
expect(configHelper.getEffectiveConfigAttributes(cluster,configTags)).andReturn(attributes);
expect(configMap.get(Configuration.SERVER_TMP_DIR_KEY)).andReturn(Configuration.SERVER_TMP_DIR_DEFAULT);
expect(configMap.get(Configuration.AMBARI_PYTHON_WRAP_KEY)).andReturn(Configuration.AMBARI_PYTHON_WRAP_DEFAULT);
expect(configuration.getConfigsMap()).andReturn(returnConfigMap);
expect(configuration.getResourceDirPath()).andReturn(stackRoot);
expect(configuration.getJavaVersion()).andReturn(8);
expect(configuration.areHostsSysPrepped()).andReturn("false");
expect(configuration.getExternalScriptTimeout()).andReturn(Integer.parseInt(Configuration.EXTERNAL_SCRIPT_TIMEOUT_DEFAULT));
Map props=new HashMap();
props.put(Configuration.HIVE_METASTORE_PASSWORD_PROPERTY,"pass");
props.put("key","value");
expect(clusterConfig.getProperties()).andReturn(props);
expect(configHelper.getEffectiveDesiredTags(cluster,hostName)).andReturn(allConfigTags);
expect(cluster.getClusterName()).andReturn(clusterName);
expect(managementController.getHostComponents((Set)anyObject())).andReturn(responses).anyTimes();
expect(cluster.getCurrentStackVersion()).andReturn(stackId);
PowerMock.mockStaticPartial(StageUtils.class,"getClusterHostInfo");
Map> clusterHostInfo=new HashMap>();
Set all_hosts=new HashSet(Arrays.asList("Host100","Host101","Host102"));
Set some_hosts=new HashSet(Arrays.asList("0-1","2"));
Set ohter_hosts=new HashSet(Arrays.asList("0,1"));
Set clusterHostTypes=new HashSet(Arrays.asList("nm_hosts","hs_host","namenode_host","rm_host","snamenode_host","slave_hosts","zookeeper_hosts"));
for ( String hostTypes : clusterHostTypes) {
if (hostTypes.equals("slave_hosts")) {
clusterHostInfo.put(hostTypes,ohter_hosts);
}
else {
clusterHostInfo.put(hostTypes,some_hosts);
}
}
Map stringHostMap=new HashMap();
stringHostMap.put(hostName,host);
clusterHostInfo.put("all_hosts",all_hosts);
expect(StageUtils.getClusterHostInfo(cluster)).andReturn(clusterHostInfo);
expect(stackId.getStackName()).andReturn(stackName).anyTimes();
expect(stackId.getStackVersion()).andReturn(stackVersion).anyTimes();
expect(ambariMetaInfo.getComponent(stackName,stackVersion,serviceName,componentName)).andReturn(componentInfo);
expect(ambariMetaInfo.getService(stackName,stackVersion,serviceName)).andReturn(serviceInfo);
expect(serviceInfo.getServicePackageFolder()).andReturn(packageFolder);
expect(ambariMetaInfo.getComponent((String)anyObject(),(String)anyObject(),(String)anyObject(),(String)anyObject())).andReturn(componentInfo).anyTimes();
expect(componentInfo.getCommandScript()).andReturn(commandScriptDefinition);
expect(componentInfo.getClientConfigFiles()).andReturn(clientConfigFileDefinitionList);
expect(cluster.getConfig("hive-site",null)).andReturn(clusterConfig);
expect(cluster.getDesiredConfigs()).andReturn(desiredConfigMap);
expect(clusters.getHost(hostName)).andReturn(host);
HashMap rcaParams=new HashMap();
rcaParams.put("key","value");
expect(managementController.getRcaParameters()).andReturn(rcaParams).anyTimes();
expect(ambariMetaInfo.getService(stackName,stackVersion,serviceName)).andReturn(serviceInfo);
expect(serviceInfo.getOsSpecifics()).andReturn(new HashMap()).anyTimes();
Set userSet=new HashSet();
userSet.add("hdfs");
expect(configHelper.getPropertyValuesWithPropertyType(stackId,PropertyInfo.PropertyType.USER,cluster)).andReturn(userSet);
PowerMock.expectNew(File.class,new Class[]{String.class},anyObject(String.class)).andReturn(mockFile).anyTimes();
PowerMock.createNiceMockAndExpectNew(PrintWriter.class,anyObject());
expect(mockFile.getParent()).andReturn("");
PowerMock.mockStatic(Runtime.class);
expect(mockFile.exists()).andReturn(true);
String commandLine="ambari-python-wrap /tmp/stacks/S1/V1/PIG/package/null generate_configs null " + "/tmp/stacks/S1/V1/PIG/package /var/lib/ambari-server/tmp/structured-out.json " + "INFO /var/lib/ambari-server/tmp";
if (System.getProperty("os.name").contains("Windows")) {
commandLine="ambari-python-wrap " + stackRoot + "\\PIG\\package\\null generate_configs null "+ stackRoot+ "\\PIG\\package /var/lib/ambari-server/tmp\\structured-out.json "+ "INFO /var/lib/ambari-server/tmp";
}
ProcessBuilder processBuilder=PowerMock.createNiceMock(ProcessBuilder.class);
PowerMock.expectNew(ProcessBuilder.class,Arrays.asList(commandLine.split("\\s+"))).andReturn(processBuilder).once();
expect(processBuilder.start()).andReturn(process).once();
InputStream inputStream=new ByteArrayInputStream("some logging info".getBytes());
expect(process.getInputStream()).andReturn(inputStream);
replay(managementController,clusters,cluster,ambariMetaInfo,stackId,componentInfo,commandScriptDefinition,clusterConfig,host,service,serviceComponent,serviceComponentHost,serviceInfo,configHelper,runtime,process,configMap);
PowerMock.replayAll();
Set resources=provider.getResources(request,predicate);
assertFalse(resources.isEmpty());
verify(managementController,clusters,cluster,ambariMetaInfo,stackId,componentInfo,commandScriptDefinition,clusterConfig,host,service,serviceComponent,serviceComponentHost,serviceInfo,configHelper,runtime,process);
PowerMock.verifyAll();
}
Class: org.apache.ambari.server.controller.internal.ClusterControllerImplTest BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyIds=new HashSet();
Request request=PropertyHelper.getReadRequest(propertyIds);
Iterable iterable=controller.getResourceIterable(Resource.Type.Host,request,null);
String lastHostName=null;
int cnt=0;
for ( Resource resource : iterable) {
Assert.assertEquals(Resource.Type.Host,resource.getType());
String hostName=(String)resource.getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name"));
if (lastHostName != null) {
Assert.assertTrue(hostName.compareTo(lastHostName) > 0);
}
lastHostName=hostName;
++cnt;
}
Assert.assertEquals(4,cnt);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier propertyIds=new HashSet();
Request request=PropertyHelper.getReadRequest(propertyIds);
PageRequest pageRequest=new PageRequestImpl(PageRequest.StartingPoint.OffsetEnd,2,2,null,null);
PageResponse pageResponse=controller.getResources(Resource.Type.Host,request,null,pageRequest,null);
Assert.assertEquals(1,pageResponse.getOffset());
Assert.assertEquals("host:0",pageResponse.getPreviousResource().getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals("host:3",pageResponse.getNextResource().getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(4,pageResponse.getTotalResourceCount().intValue());
Iterable iterable=pageResponse.getIterable();
List list=new LinkedList();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(2,list.size());
Assert.assertEquals("host:1",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
Assert.assertEquals("host:2",(String)list.get(1).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(1).getType());
pageRequest=new PageRequestImpl(PageRequest.StartingPoint.OffsetEnd,3,2,null,null);
pageResponse=controller.getResources(Resource.Type.Host,request,null,pageRequest,null);
Assert.assertEquals(0,pageResponse.getOffset());
Assert.assertNull(pageResponse.getPreviousResource());
Assert.assertEquals("host:3",pageResponse.getNextResource().getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
iterable=pageResponse.getIterable();
list=new LinkedList();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(3,list.size());
Assert.assertEquals("host:0",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
Assert.assertEquals("host:1",(String)list.get(1).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(1).getType());
Assert.assertEquals("host:2",(String)list.get(2).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(2).getType());
Assert.assertEquals(4,pageResponse.getTotalResourceCount().intValue());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier propertyIds=new HashSet();
Request request=PropertyHelper.getReadRequest(propertyIds);
Predicate predicate=new PredicateBuilder().property("c1/p2").equals(1).toPredicate();
List sortRequestProperties=Collections.singletonList(new SortRequestProperty("Hosts/host_name",SortRequest.Order.DESC));
SortRequest sortRequest=new SortRequestImpl(sortRequestProperties);
PageRequest pageRequest=new PageRequestImpl(PageRequest.StartingPoint.Beginning,1,0,null,null);
PageResponse pageResponse=controller.getResources(Resource.Type.Host,request,predicate,pageRequest,sortRequest);
Iterable iterable=pageResponse.getIterable();
List list=new LinkedList();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(1,list.size());
Assert.assertEquals(2,pageResponse.getTotalResourceCount().intValue());
Assert.assertEquals("host:3",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
pageRequest=new PageRequestImpl(PageRequest.StartingPoint.OffsetStart,1,1,null,null);
pageResponse=controller.getResources(Resource.Type.Host,request,predicate,pageRequest,sortRequest);
iterable=pageResponse.getIterable();
list.clear();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(1,list.size());
Assert.assertEquals(2,pageResponse.getTotalResourceCount().intValue());
Assert.assertEquals("host:1",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
}
InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier propertyIds=new HashSet();
Request request=PropertyHelper.getReadRequest(propertyIds);
PageRequest pageRequest=new PageRequestImpl(PageRequest.StartingPoint.Beginning,2,0,null,null);
PageResponse pageResponse=controller.getResources(Resource.Type.Host,request,null,pageRequest,null);
Iterable iterable=pageResponse.getIterable();
List list=new LinkedList();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(2,list.size());
Assert.assertEquals("host:0",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
Assert.assertEquals("host:1",(String)list.get(1).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(1).getType());
Assert.assertEquals(4,pageResponse.getTotalResourceCount().intValue());
pageRequest=new PageRequestImpl(PageRequest.StartingPoint.Beginning,3,0,null,null);
pageResponse=controller.getResources(Resource.Type.Host,request,null,pageRequest,null);
iterable=pageResponse.getIterable();
list=new LinkedList();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(3,list.size());
Assert.assertEquals("host:0",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
Assert.assertEquals("host:1",(String)list.get(1).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(1).getType());
Assert.assertEquals("host:2",(String)list.get(2).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(2).getType());
Assert.assertEquals(4,pageResponse.getTotalResourceCount().intValue());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier propertyMap=new HashMap();
propertyMap.put(PropertyHelper.getPropertyId("c1","p1"),99);
propertyMap.put(PropertyHelper.getPropertyId("c1","p2"),2);
Request request=PropertyHelper.getUpdateRequest(propertyMap,null);
Predicate predicate=new PredicateBuilder().property("c3/p6").equals(1).toPredicate();
controller.updateResources(Resource.Type.Host,request,predicate);
Assert.assertEquals(TestHostResourceProvider.Action.Update,resourceProvider.getLastAction());
Assert.assertSame(request,resourceProvider.getLastRequest());
Predicate lastPredicate=resourceProvider.getLastPredicate();
Assert.assertFalse(predicate.equals(lastPredicate));
Set predicatePropertyIds=PredicateHelper.getPropertyIds(lastPredicate);
Collection keyPropertyIds=resourceProvider.getKeyPropertyIds().values();
Assert.assertEquals(predicatePropertyIds.size(),keyPropertyIds.size());
Assert.assertTrue(keyPropertyIds.containsAll(predicatePropertyIds));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier predicatePropertyIds=PredicateHelper.getPropertyIds(lastPredicate);
Collection keyPropertyIds=resourceProvider.getKeyPropertyIds().values();
Assert.assertEquals(predicatePropertyIds.size(),keyPropertyIds.size());
Assert.assertTrue(keyPropertyIds.containsAll(predicatePropertyIds));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier propertyIds=new HashSet();
Request request=PropertyHelper.getReadRequest(propertyIds);
PageRequest pageRequest=new PageRequestImpl(PageRequest.StartingPoint.End,2,0,null,null);
PageResponse pageResponse=controller.getResources(Resource.Type.Host,request,null,pageRequest,null);
Iterable iterable=pageResponse.getIterable();
List list=new LinkedList();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(2,list.size());
Assert.assertEquals("host:2",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
Assert.assertEquals("host:3",(String)list.get(1).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(1).getType());
Assert.assertEquals(4,pageResponse.getTotalResourceCount().intValue());
pageRequest=new PageRequestImpl(PageRequest.StartingPoint.End,3,0,null,null);
pageResponse=controller.getResources(Resource.Type.Host,request,null,pageRequest,null);
iterable=pageResponse.getIterable();
list=new LinkedList();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(3,list.size());
Assert.assertEquals("host:1",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
Assert.assertEquals("host:2",(String)list.get(1).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(1).getType());
Assert.assertEquals("host:3",(String)list.get(2).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(2).getType());
Assert.assertEquals(4,pageResponse.getTotalResourceCount().intValue());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier > properties=new HashSet>();
Map propertyMap=new HashMap();
propertyMap.put(PropertyHelper.getPropertyId("c1","p1"),99);
propertyMap.put(PropertyHelper.getPropertyId("c1","p2"),2);
properties.add(propertyMap);
Request request=PropertyHelper.getCreateRequest(properties,null);
controller.createResources(Resource.Type.Host,request);
Assert.assertEquals(TestHostResourceProvider.Action.Create,resourceProvider.getLastAction());
Assert.assertSame(request,resourceProvider.getLastRequest());
Assert.assertNull(resourceProvider.getLastPredicate());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier HybridVerifier propertyMap=new HashMap();
propertyMap.put(PropertyHelper.getPropertyId("c1","p1"),99);
propertyMap.put(PropertyHelper.getPropertyId("c1","p2"),2);
Request request=PropertyHelper.getUpdateRequest(propertyMap,null);
Predicate predicate=new PredicateBuilder().property("c1/p2").equals(1).toPredicate();
controller.updateResources(Resource.Type.Host,request,predicate);
Assert.assertEquals(TestHostResourceProvider.Action.Update,resourceProvider.getLastAction());
Assert.assertSame(request,resourceProvider.getLastRequest());
Assert.assertSame(predicate,resourceProvider.getLastPredicate());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier comparator=controller.getComparator();
Resource resource1=new ResourceImpl(Resource.Type.Host);
Resource resource2=new ResourceImpl(Resource.Type.Host);
Resource resource3=new ResourceImpl(Resource.Type.Service);
Assert.assertEquals(0,comparator.compare(resource1,resource2));
Assert.assertEquals(0,comparator.compare(resource2,resource1));
Assert.assertTrue(comparator.compare(resource1,resource3) < 0);
Assert.assertTrue(comparator.compare(resource3,resource1) > 0);
resource1.setProperty(PropertyHelper.getPropertyId("Hosts","cluster_name"),"c1");
resource1.setProperty(PropertyHelper.getPropertyId("Hosts","host_name"),"h1");
resource2.setProperty(PropertyHelper.getPropertyId("Hosts","cluster_name"),"c1");
resource2.setProperty(PropertyHelper.getPropertyId("Hosts","host_name"),"h1");
Assert.assertEquals(0,comparator.compare(resource1,resource2));
Assert.assertEquals(0,comparator.compare(resource2,resource1));
resource2.setProperty(PropertyHelper.getPropertyId("Hosts","host_name"),"h2");
Assert.assertTrue(comparator.compare(resource1,resource2) < 0);
Assert.assertTrue(comparator.compare(resource2,resource1) > 0);
resource2.setProperty(PropertyHelper.getPropertyId("Hosts","host_name"),"h1");
resource1.setProperty("p1","foo");
resource2.setProperty("p1","foo");
Assert.assertEquals(0,comparator.compare(resource1,resource2));
Assert.assertEquals(0,comparator.compare(resource2,resource1));
resource2.setProperty("p1","bar");
Assert.assertFalse(comparator.compare(resource1,resource2) == 0);
Assert.assertFalse(comparator.compare(resource2,resource1) == 0);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier propertyIds=new HashSet();
Request request=PropertyHelper.getReadRequest(propertyIds);
PageRequest pageRequest=new PageRequestImpl(PageRequest.StartingPoint.OffsetStart,2,1,null,null);
PageResponse pageResponse=controller.getResources(Resource.Type.Host,request,null,pageRequest,null);
Assert.assertEquals(1,pageResponse.getOffset());
Assert.assertEquals("host:0",pageResponse.getPreviousResource().getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals("host:3",pageResponse.getNextResource().getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Iterable iterable=pageResponse.getIterable();
List list=new LinkedList();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(2,list.size());
Assert.assertEquals("host:1",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
Assert.assertEquals("host:2",(String)list.get(1).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(1).getType());
Assert.assertEquals(4,pageResponse.getTotalResourceCount().intValue());
pageRequest=new PageRequestImpl(PageRequest.StartingPoint.OffsetStart,3,0,null,null);
pageResponse=controller.getResources(Resource.Type.Host,request,null,pageRequest,null);
Assert.assertEquals(0,pageResponse.getOffset());
Assert.assertNull(pageResponse.getPreviousResource());
Assert.assertEquals("host:3",pageResponse.getNextResource().getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
iterable=pageResponse.getIterable();
list=new LinkedList();
for ( Resource resource : iterable) {
list.add(resource);
}
Assert.assertEquals(3,list.size());
Assert.assertEquals("host:0",(String)list.get(0).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(0).getType());
Assert.assertEquals("host:1",(String)list.get(1).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(1).getType());
Assert.assertEquals("host:2",(String)list.get(2).getPropertyValue(PropertyHelper.getPropertyId("Hosts","host_name")));
Assert.assertEquals(Resource.Type.Host,list.get(2).getType());
Assert.assertEquals(4,pageResponse.getTotalResourceCount().intValue());
}
Class: org.apache.ambari.server.controller.internal.ClusterResourceProviderTest InternalCallVerifier EqualityVerifier > requestProperties=createBlueprintRequestProperties(CLUSTER_NAME,BLUEPRINT_NAME);
Map properties=requestProperties.iterator().next();
properties.put(ProvisionClusterRequest.PROVISION_ACTION_PROPERTY,"INSTALL_ONLY");
Map requestInfoProperties=new HashMap();
requestInfoProperties.put(Request.REQUEST_INFO_BODY_PROPERTY,"{}");
expect(request.getProperties()).andReturn(requestProperties).anyTimes();
expect(request.getRequestInfoProperties()).andReturn(requestInfoProperties).anyTimes();
expect(securityFactory.createSecurityConfigurationFromRequest(anyObject(HashMap.class),anyBoolean())).andReturn(null).once();
expect(topologyFactory.createProvisionClusterRequest(properties,null)).andReturn(topologyRequest).once();
expect(topologyManager.provisionCluster(topologyRequest)).andReturn(requestStatusResponse).once();
expect(requestStatusResponse.getRequestId()).andReturn(5150L).anyTimes();
replayAll();
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
RequestStatus requestStatus=provider.createResources(request);
assertEquals(5150L,requestStatus.getRequestResource().getPropertyValue(PropertyHelper.getPropertyId("Requests","id")));
assertEquals(Resource.Type.Request,requestStatus.getRequestResource().getType());
assertEquals("Accepted",requestStatus.getRequestResource().getPropertyValue(PropertyHelper.getPropertyId("Requests","status")));
verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > propertySet=new LinkedHashSet>();
Map properties=new LinkedHashMap();
properties.put(ClusterResourceProvider.CLUSTER_NAME_PROPERTY_ID,"Cluster100");
properties.put(ClusterResourceProvider.CLUSTER_VERSION_PROPERTY_ID,"HDP-0.1");
propertySet.add(properties);
Request request=PropertyHelper.getCreateRequest(propertySet,null);
provider.createResources(request);
ResourceProviderEvent lastEvent=observer.getLastEvent();
Assert.assertNotNull(lastEvent);
Assert.assertEquals(Resource.Type.Cluster,lastEvent.getResourceType());
Assert.assertEquals(ResourceProviderEvent.Type.Create,lastEvent.getType());
Assert.assertEquals(request,lastEvent.getRequest());
Assert.assertNull(lastEvent.getPredicate());
verify(managementController,response);
RetryHelper.init(0);
}
InternalCallVerifier EqualityVerifier > requestProperties=createBlueprintRequestProperties(CLUSTER_NAME,BLUEPRINT_NAME);
Map properties=requestProperties.iterator().next();
SecurityConfiguration securityConfiguration=new SecurityConfiguration(SecurityType.KERBEROS,"testRef",null);
Map requestInfoProperties=new HashMap();
requestInfoProperties.put(Request.REQUEST_INFO_BODY_PROPERTY,"{\"security\" : {\n\"type\" : \"KERBEROS\",\n\"kerberos_descriptor_reference\" : " + "\"testRef\"\n}}");
expect(request.getProperties()).andReturn(requestProperties).anyTimes();
expect(request.getRequestInfoProperties()).andReturn(requestInfoProperties).anyTimes();
expect(topologyFactory.createProvisionClusterRequest(properties,securityConfiguration)).andReturn(topologyRequest).once();
expect(securityFactory.createSecurityConfigurationFromRequest(anyObject(HashMap.class),anyBoolean())).andReturn(securityConfiguration).once();
expect(topologyManager.provisionCluster(topologyRequest)).andReturn(requestStatusResponse).once();
expect(requestStatusResponse.getRequestId()).andReturn(5150L).anyTimes();
replayAll();
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
RequestStatus requestStatus=provider.createResources(request);
assertEquals(5150L,requestStatus.getRequestResource().getPropertyValue(PropertyHelper.getPropertyId("Requests","id")));
assertEquals(Resource.Type.Request,requestStatus.getRequestResource().getType());
assertEquals("Accepted",requestStatus.getRequestResource().getPropertyValue(PropertyHelper.getPropertyId("Requests","status")));
verifyAll();
}
Class: org.apache.ambari.server.controller.internal.ClusterStackVersionResourceProviderTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier schs=Collections.singletonList(sch);
Cluster cluster=createNiceMock(Cluster.class);
cluster.setClusterName(clusterName);
ArrayList hosts=new ArrayList(){
{
add(host1);
add(host2);
}
}
;
Clusters clusters=createNiceMock(Clusters.class);
expect(clusters.getCluster(anyObject(String.class))).andReturn(cluster);
RepositoryVersionEntity repoVersion=new RepositoryVersionEntity();
repoVersion.setOperatingSystems(operatingSystemsJson);
StackEntity newDesiredStack=stackDAO.find("HDP","2.0.1");
repoVersion.setStack(newDesiredStack);
final ServiceOsSpecific.Package hivePackage=new ServiceOsSpecific.Package();
hivePackage.setName("hive");
final ServiceOsSpecific.Package mysqlPackage=new ServiceOsSpecific.Package();
mysqlPackage.setName("mysql");
mysqlPackage.setSkipUpgrade(Boolean.TRUE);
List packages=new ArrayList(){
{
add(hivePackage);
add(mysqlPackage);
}
}
;
ActionManager actionManager=createNiceMock(ActionManager.class);
RequestStatusResponse response=createNiceMock(RequestStatusResponse.class);
ResourceProviderFactory resourceProviderFactory=createNiceMock(ResourceProviderFactory.class);
ResourceProvider csvResourceProvider=createNiceMock(ClusterStackVersionResourceProvider.class);
AbstractControllerResourceProvider.init(resourceProviderFactory);
Map> hostConfigTags=new HashMap>();
expect(configHelper.getEffectiveDesiredTags(anyObject(ClusterImpl.class),anyObject(String.class))).andReturn(hostConfigTags);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getAuthName()).andReturn("admin").anyTimes();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(managementController.getJdkResourceUrl()).andReturn("/JdkResourceUrl").anyTimes();
expect(managementController.getPackagesForServiceHost(anyObject(ServiceInfo.class),(Map)anyObject(List.class),anyObject(String.class))).andReturn(packages).anyTimes();
expect(resourceProviderFactory.getHostResourceProvider(anyObject(Set.class),anyObject(Map.class),eq(managementController))).andReturn(csvResourceProvider).anyTimes();
expect(cluster.getCurrentStackVersion()).andReturn(stackId);
expect(cluster.getServiceComponentHosts(anyObject(String.class))).andReturn(schs).anyTimes();
RepositoryVersionEntity currentRepo=new RepositoryVersionEntity();
currentRepo.setVersion("2.2.2.0-2122");
ClusterVersionEntity current=new ClusterVersionEntity();
current.setRepositoryVersion(currentRepo);
Capture capturedStackId=new Capture();
cluster.setDesiredStackVersion(capture(capturedStackId));
expectLastCall().once();
expect(cluster.getHosts()).andReturn(hosts).anyTimes();
expect(cluster.getCurrentClusterVersion()).andReturn(current).anyTimes();
expect(sch.getServiceName()).andReturn("HIVE").anyTimes();
expect(repositoryVersionDAOMock.findByDisplayName(anyObject(String.class))).andReturn(repoVersion);
clusterVersionDAO.updateVersions((Long)anyObject(),(RepositoryVersionEntity)anyObject(),(RepositoryVersionEntity)anyObject());
expectLastCall().once();
hostVersionDAO.updateVersions((RepositoryVersionEntity)anyObject(),(RepositoryVersionEntity)anyObject());
expectLastCall().once();
hostComponentStateDAO.updateVersions((String)anyObject());
expectLastCall().once();
replay(managementController,response,clusters,resourceProviderFactory,csvResourceProvider,cluster,repositoryVersionDAOMock,configHelper,sch,actionManager,clusterVersionDAO,hostVersionDAO,hostComponentStateDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
injector.injectMembers(provider);
Map properties=new LinkedHashMap();
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_CLUSTER_NAME_PROPERTY_ID,clusterName);
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_STATE_PROPERTY_ID,"CURRENT");
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_REPOSITORY_VERSION_PROPERTY_ID,"HDP-2.2.2.0-2561");
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_FORCE,"true");
Request request=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(request,null);
verify(managementController,response,clusterVersionDAO,hostVersionDAO,hostComponentStateDAO);
Assert.assertEquals(capturedStackId.getValue(),new StackId(newDesiredStack.getStackName(),newDesiredStack.getStackVersion()));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier schs=Collections.singletonList(sch);
Cluster cluster=createNiceMock(Cluster.class);
cluster.setClusterName(clusterName);
ArrayList hosts=new ArrayList(){
{
add(host1);
add(host2);
}
}
;
Clusters clusters=createNiceMock(Clusters.class);
expect(clusters.getCluster(anyObject(String.class))).andReturn(cluster);
RepositoryVersionEntity repoVersion=new RepositoryVersionEntity();
repoVersion.setOperatingSystems(operatingSystemsJson);
StackEntity newDesiredStack=stackDAO.find("HDP","2.0.1");
repoVersion.setStack(newDesiredStack);
final ServiceOsSpecific.Package hivePackage=new ServiceOsSpecific.Package();
hivePackage.setName("hive");
final ServiceOsSpecific.Package mysqlPackage=new ServiceOsSpecific.Package();
mysqlPackage.setName("mysql");
mysqlPackage.setSkipUpgrade(Boolean.TRUE);
List packages=new ArrayList(){
{
add(hivePackage);
add(mysqlPackage);
}
}
;
ActionManager actionManager=createNiceMock(ActionManager.class);
RequestStatusResponse response=createNiceMock(RequestStatusResponse.class);
ResourceProviderFactory resourceProviderFactory=createNiceMock(ResourceProviderFactory.class);
ResourceProvider csvResourceProvider=createNiceMock(ClusterStackVersionResourceProvider.class);
CommandReport report=createNiceMock(CommandReport.class);
FinalizeUpgradeAction finalizeUpgradeAction=createNiceMock(FinalizeUpgradeAction.class);
AbstractControllerResourceProvider.init(resourceProviderFactory);
Map> hostConfigTags=new HashMap>();
expect(configHelper.getEffectiveDesiredTags(anyObject(ClusterImpl.class),anyObject(String.class))).andReturn(hostConfigTags);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getAuthName()).andReturn("admin").anyTimes();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(managementController.getJdkResourceUrl()).andReturn("/JdkResourceUrl").anyTimes();
expect(managementController.getPackagesForServiceHost(anyObject(ServiceInfo.class),(Map)anyObject(List.class),anyObject(String.class))).andReturn(packages).anyTimes();
expect(resourceProviderFactory.getHostResourceProvider(anyObject(Set.class),anyObject(Map.class),eq(managementController))).andReturn(csvResourceProvider).anyTimes();
expect(cluster.getCurrentStackVersion()).andReturn(stackId);
expect(cluster.getServiceComponentHosts(anyObject(String.class))).andReturn(schs).anyTimes();
Capture capturedStackId=new Capture();
cluster.setDesiredStackVersion(capture(capturedStackId));
expectLastCall().once();
expect(cluster.getHosts()).andReturn(hosts).anyTimes();
expect(sch.getServiceName()).andReturn("HIVE").anyTimes();
expect(repositoryVersionDAOMock.findByDisplayName(anyObject(String.class))).andReturn(repoVersion);
expect(actionManager.getRequestTasks(anyLong())).andReturn(Collections.emptyList()).anyTimes();
expect(finalizeUpgradeAction.execute(null)).andReturn(report);
expect(report.getStdOut()).andReturn("Dummy stdout");
expect(report.getStdErr()).andReturn("Dummy stderr");
expect(report.getStatus()).andReturn("COMPLETED");
replay(managementController,response,clusters,resourceProviderFactory,csvResourceProvider,cluster,repositoryVersionDAOMock,configHelper,sch,actionManager,finalizeUpgradeAction,report,stageFactory);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
injector.injectMembers(provider);
Field field=ClusterStackVersionResourceProvider.class.getDeclaredField("finalizeUpgradeAction");
field.setAccessible(true);
field.set(provider,finalizeUpgradeAction);
Map properties=new LinkedHashMap();
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_CLUSTER_NAME_PROPERTY_ID,clusterName);
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_STATE_PROPERTY_ID,"CURRENT");
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_REPOSITORY_VERSION_PROPERTY_ID,"HDP-2.2.2.0-2561");
Request request=PropertyHelper.getUpdateRequest(properties,null);
provider.updateResources(request,null);
verify(managementController,response);
Assert.assertEquals(capturedStackId.getValue(),new StackId(newDesiredStack.getStackName(),newDesiredStack.getStackVersion()));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hostsForCluster=new HashMap();
int hostCount=10;
for (int i=0; i < hostCount; i++) {
String hostname="host" + i;
Host host=createNiceMock(hostname,Host.class);
expect(host.getHostName()).andReturn(hostname).anyTimes();
expect(host.getOsFamily()).andReturn("redhat6").anyTimes();
expect(host.getMaintenanceState(EasyMock.anyLong())).andReturn(MaintenanceState.OFF).anyTimes();
replay(host);
hostsForCluster.put(hostname,host);
}
final ServiceComponentHost schDatanode=createMock(ServiceComponentHost.class);
expect(schDatanode.getServiceName()).andReturn("HDFS").anyTimes();
expect(schDatanode.getServiceComponentName()).andReturn("DATANODE").anyTimes();
final ServiceComponentHost schNamenode=createMock(ServiceComponentHost.class);
expect(schNamenode.getServiceName()).andReturn("HDFS").anyTimes();
expect(schNamenode.getServiceComponentName()).andReturn("NAMENODE").anyTimes();
final ServiceComponentHost schAMS=createMock(ServiceComponentHost.class);
expect(schAMS.getServiceName()).andReturn("AMBARI_METRICS").anyTimes();
expect(schAMS.getServiceComponentName()).andReturn("METRICS_COLLECTOR").anyTimes();
final List schsH1=new ArrayList(){
{
add(schDatanode);
add(schNamenode);
add(schAMS);
}
}
;
final List schsH2=new ArrayList(){
{
add(schAMS);
}
}
;
RepositoryVersionEntity repoVersion=new RepositoryVersionEntity();
repoVersion.setId(1l);
repoVersion.setOperatingSystems(operatingSystemsJson);
ServiceOsSpecific.Package hdfsPackage=new ServiceOsSpecific.Package();
hdfsPackage.setName("hdfs");
List packages=Collections.singletonList(hdfsPackage);
ActionManager actionManager=createNiceMock(ActionManager.class);
RequestStatusResponse response=createNiceMock(RequestStatusResponse.class);
ResourceProviderFactory resourceProviderFactory=createNiceMock(ResourceProviderFactory.class);
ResourceProvider csvResourceProvider=createNiceMock(ClusterStackVersionResourceProvider.class);
AbstractControllerResourceProvider.init(resourceProviderFactory);
Map> hostConfigTags=new HashMap>();
expect(configHelper.getEffectiveDesiredTags(anyObject(ClusterImpl.class),anyObject(String.class))).andReturn(hostConfigTags);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getAuthName()).andReturn("admin").anyTimes();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(managementController.getJdkResourceUrl()).andReturn("/JdkResourceUrl").anyTimes();
expect(managementController.getPackagesForServiceHost(anyObject(ServiceInfo.class),(Map)anyObject(List.class),anyObject(String.class))).andReturn(packages).times((hostCount - 1) * 2);
expect(resourceProviderFactory.getHostResourceProvider(anyObject(Set.class),anyObject(Map.class),eq(managementController))).andReturn(csvResourceProvider).anyTimes();
expect(clusters.getCluster(anyObject(String.class))).andReturn(cluster);
expect(clusters.getHostsForCluster(anyObject(String.class))).andReturn(hostsForCluster).anyTimes();
String clusterName="Cluster100";
expect(cluster.getClusterId()).andReturn(1L).anyTimes();
expect(cluster.getHosts()).andReturn(hostsForCluster.values()).atLeastOnce();
expect(cluster.getServices()).andReturn(new HashMap()).anyTimes();
expect(cluster.getCurrentStackVersion()).andReturn(stackId);
expect(cluster.getServiceComponentHosts(anyObject(String.class))).andAnswer(new IAnswer>(){
@Override public List answer() throws Throwable {
String hostname=(String)EasyMock.getCurrentArguments()[0];
if (hostname.equals("host2")) {
return schsH2;
}
else {
return schsH1;
}
}
}
).anyTimes();
ExecutionCommand executionCommand=createNiceMock(ExecutionCommand.class);
ExecutionCommandWrapper executionCommandWrapper=createNiceMock(ExecutionCommandWrapper.class);
expect(executionCommandWrapper.getExecutionCommand()).andReturn(executionCommand).anyTimes();
Stage stage=createNiceMock(Stage.class);
expect(stage.getExecutionCommandWrapper(anyObject(String.class),anyObject(String.class))).andReturn(executionCommandWrapper).anyTimes();
Map successFactors=new HashMap<>();
expect(stage.getSuccessFactors()).andReturn(successFactors).atLeastOnce();
expect(stageFactory.createNew(anyLong(),anyObject(String.class),anyObject(String.class),anyLong(),anyObject(String.class),anyObject(String.class),anyObject(String.class),anyObject(String.class))).andReturn(stage).times((int)Math.ceil(hostCount / MAX_TASKS_PER_STAGE));
expect(repositoryVersionDAOMock.findByStackAndVersion(anyObject(StackId.class),anyObject(String.class))).andReturn(repoVersion);
expect(actionManager.getRequestTasks(anyLong())).andReturn(Collections.emptyList()).anyTimes();
ClusterEntity clusterEntity=new ClusterEntity();
clusterEntity.setClusterId(1l);
clusterEntity.setClusterName(clusterName);
ClusterVersionEntity cve=new ClusterVersionEntity(clusterEntity,repoVersion,RepositoryVersionState.INSTALL_FAILED,0,"");
expect(clusterVersionDAO.findByClusterAndStackAndVersion(anyObject(String.class),anyObject(StackId.class),anyObject(String.class))).andReturn(cve);
TopologyManager topologyManager=injector.getInstance(TopologyManager.class);
StageUtils.setTopologyManager(topologyManager);
replay(managementController,response,clusters,resourceProviderFactory,csvResourceProvider,cluster,repositoryVersionDAOMock,configHelper,schDatanode,schNamenode,schAMS,actionManager,executionCommand,executionCommandWrapper,stage,stageFactory,clusterVersionDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
injector.injectMembers(provider);
Set> propertySet=new LinkedHashSet>();
Map properties=new LinkedHashMap();
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_CLUSTER_NAME_PROPERTY_ID,"Cluster100");
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_REPOSITORY_VERSION_PROPERTY_ID,"2.2.0.1-885");
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_STACK_PROPERTY_ID,"HDP");
properties.put(ClusterStackVersionResourceProvider.CLUSTER_STACK_VERSION_VERSION_PROPERTY_ID,"2.1.1");
propertySet.add(properties);
Request request=PropertyHelper.getCreateRequest(propertySet,null);
RequestStatus status=provider.createResources(request);
Assert.assertNotNull(status);
verify(managementController,response,clusters,stageFactory,stage);
Float successFactor=successFactors.get(Role.INSTALL_PACKAGES);
Assert.assertEquals(Float.valueOf(0.85f),successFactor);
}
Class: org.apache.ambari.server.controller.internal.CompatibleRepositoryVersionResourceProviderTest InternalCallVerifier EqualityVerifier resources=compatibleProvider.getResources(getRequest,new AndPredicate(predicateStackName,predicateStackVersion));
assertEquals(2,resources.size());
Map> versionToUpgradeTypesMap=new HashMap>();
versionToUpgradeTypesMap.put("1.1",Arrays.asList("ROLLING"));
versionToUpgradeTypesMap.put("2.2",Arrays.asList("NON_ROLLING","ROLLING"));
assertEquals(versionToUpgradeTypesMap.size(),checkUpgradeTypes(resources,versionToUpgradeTypesMap));
}
Class: org.apache.ambari.server.controller.internal.ComponentResourceProviderTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
setRequests.add(request4);
setRequests.add(request5);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(stackId.getStackName()).andReturn("stackName").anyTimes();
expect(stackId.getStackVersion()).andReturn("1").anyTimes();
expect(clusters.getCluster("cluster1")).andReturn(cluster).anyTimes();
expect(cluster.getDesiredStackVersion()).andReturn(stackId).anyTimes();
expect(cluster.getService("service1")).andReturn(service).anyTimes();
expect(cluster.getService("service2")).andThrow(new ObjectNotFoundException("service2"));
expect(ambariMetaInfo.getComponent("stackName","1","service1","component3")).andReturn(component3Info);
expect(ambariMetaInfo.getComponent("stackName","1","service1","component4")).andReturn(component4Info);
expect(component3Info.getCategory()).andReturn(null);
expect(component4Info.getCategory()).andReturn(null);
expect(service.getName()).andReturn("service1").anyTimes();
expect(service.getServiceComponent("component1")).andThrow(new ServiceComponentNotFoundException("cluster1","service1","component1"));
expect(service.getServiceComponent("component2")).andThrow(new ServiceComponentNotFoundException("cluster1","service1","component2"));
expect(service.getServiceComponent("component3")).andReturn(component1);
expect(service.getServiceComponent("component4")).andReturn(component2);
expect(component1.convertToResponse()).andReturn(response1);
expect(component2.convertToResponse()).andReturn(response2);
replay(clusters,cluster,service,component3Info,component4Info,component1,component2,response1,response2,ambariMetaInfo,stackId,managementController);
Set setResponses=getComponentResourceProvider(managementController).getComponents(setRequests);
assertEquals(2,setResponses.size());
assertTrue(setResponses.contains(response1));
assertTrue(setResponses.contains(response2));
verify(clusters,cluster,service,component3Info,component4Info,component1,component2,response1,response2,ambariMetaInfo,stackId,managementController);
}
UtilityVerifier InternalCallVerifier IdentityVerifier HybridVerifier controllerCapture=EasyMock.newCapture();
Clusters clusters=createNiceMock(Clusters.class);
MaintenanceStateHelper maintHelper=createNiceMock(MaintenanceStateHelper.class);
Cluster cluster=createNiceMock(Cluster.class);
Service service=createNiceMock(Service.class);
ServiceComponentRequest request1=new ServiceComponentRequest("cluster1","service1","component1",null);
Set setRequests=new HashSet();
setRequests.add(request1);
injector.injectMembers(capture(controllerCapture));
expect(injector.getInstance(Gson.class)).andReturn(null);
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(maintHelper);
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class));
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(cluster.getService("service1")).andReturn(service);
expect(service.getServiceComponent("component1")).andThrow(new ServiceComponentNotFoundException("cluster1","service1","component1"));
replay(maintHelper,injector,clusters,cluster,service);
AmbariManagementController controller=new AmbariManagementControllerImpl(null,clusters,injector);
try {
getComponentResourceProvider(controller).getComponents(setRequests);
fail("expected ServiceComponentNotFoundException");
}
catch ( ServiceComponentNotFoundException e) {
}
assertSame(controller,controllerCapture.getValue());
verify(injector,clusters,cluster,service);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier setRequests=new HashSet();
setRequests.add(request1);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(stackId.getStackName()).andReturn("stackName").anyTimes();
expect(stackId.getStackVersion()).andReturn("1").anyTimes();
expect(clusters.getCluster("cluster1")).andReturn(cluster);
expect(cluster.getService("service1")).andReturn(service);
expect(cluster.getDesiredStackVersion()).andReturn(stackId).anyTimes();
expect(service.getName()).andReturn("service1").anyTimes();
expect(service.getServiceComponent("component1")).andReturn(component);
expect(ambariMetaInfo.getComponent("stackName","1","service1","component1")).andReturn(componentInfo);
expect(componentInfo.getCategory()).andReturn(null);
expect(component.convertToResponse()).andReturn(response);
replay(clusters,cluster,service,componentInfo,component,response,ambariMetaInfo,stackId,managementController);
Set setResponses=getComponentResourceProvider(managementController).getComponents(setRequests);
assertEquals(1,setResponses.size());
assertTrue(setResponses.contains(response));
verify(clusters,cluster,service,componentInfo,component,response,ambariMetaInfo,stackId,managementController);
}
Class: org.apache.ambari.server.controller.internal.ConfigGroupResourceProviderTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier clusterCapture=new Capture();
Capture captureName=new Capture();
Capture captureDesc=new Capture();
Capture captureTag=new Capture();
Capture> captureConfigs=new Capture>();
Capture> captureHosts=new Capture>();
expect(configGroupFactory.createNew(capture(clusterCapture),capture(captureName),capture(captureTag),capture(captureDesc),capture(captureConfigs),capture(captureHosts))).andReturn(configGroup);
replay(managementController,clusters,cluster,configGroupFactory,configGroup,response,hostDAO,hostEntity1,hostEntity2);
ResourceProvider provider=getConfigGroupResourceProvider(managementController);
Set> propertySet=new LinkedHashSet>();
Map properties=new LinkedHashMap();
Set> hostSet=new HashSet>();
Map host1=new HashMap();
host1.put(ConfigGroupResourceProvider.CONFIGGROUP_HOSTNAME_PROPERTY_ID,"h1");
hostSet.add(host1);
Map host2=new HashMap();
host2.put(ConfigGroupResourceProvider.CONFIGGROUP_HOSTNAME_PROPERTY_ID,"h2");
hostSet.add(host2);
Set> configSet=new HashSet>();
Map configMap=new HashMap();
Map configs=new HashMap();
configs.put("type","core-site");
configs.put("tag","version100");
configMap.put("key1","value1");
configs.put("properties",configMap);
configSet.add(configs);
properties.put(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID,"Cluster100");
properties.put(ConfigGroupResourceProvider.CONFIGGROUP_NAME_PROPERTY_ID,"test-1");
properties.put(ConfigGroupResourceProvider.CONFIGGROUP_TAG_PROPERTY_ID,"tag-1");
properties.put(ConfigGroupResourceProvider.CONFIGGROUP_HOSTS_PROPERTY_ID,hostSet);
properties.put(ConfigGroupResourceProvider.CONFIGGROUP_CONFIGS_PROPERTY_ID,configSet);
propertySet.add(properties);
Request request=PropertyHelper.getCreateRequest(propertySet,null);
provider.createResources(request);
verify(managementController,clusters,cluster,configGroupFactory,configGroup,response,hostDAO,hostEntity1,hostEntity2);
assertEquals("version100",captureConfigs.getValue().get("core-site").getTag());
assertTrue(captureHosts.getValue().containsKey(1L));
assertTrue(captureHosts.getValue().containsKey(2L));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > desiredConfigProperties=new HashSet>();
Map desiredConfig1=new HashMap();
desiredConfig1.put("tag","version2");
desiredConfig1.put("type","type1");
desiredConfig1.put("properties/key1","value1");
desiredConfig1.put("properties/key2","value2");
desiredConfig1.put("properties_attributes/attr1/key1","true");
desiredConfig1.put("properties_attributes/attr1/key2","false");
desiredConfig1.put("properties_attributes/attr2/key1","15");
desiredConfigProperties.add(desiredConfig1);
Map properties=new HashMap();
properties.put("ConfigGroup/hosts",new HashMap(){
{
put("host_name","ambari1");
}
}
);
properties.put("ConfigGroup/cluster_name","c");
properties.put("ConfigGroup/desired_configs",desiredConfigProperties);
ConfigGroupRequest request=resourceProvider.getConfigGroupRequest(properties);
assertNotNull(request);
Map configMap=request.getConfigs();
assertNotNull(configMap);
assertEquals(1,configMap.size());
assertTrue(configMap.containsKey("type1"));
Config config=configMap.get("type1");
assertEquals("type1",config.getType());
Map configProperties=config.getProperties();
assertNotNull(configProperties);
assertEquals(2,configProperties.size());
assertEquals("value1",configProperties.get("key1"));
assertEquals("value2",configProperties.get("key2"));
Map> configAttributes=config.getPropertiesAttributes();
assertNotNull(configAttributes);
assertEquals(2,configAttributes.size());
assertTrue(configAttributes.containsKey("attr1"));
Map attr1=configAttributes.get("attr1");
assertNotNull(attr1);
assertEquals(2,attr1.size());
assertEquals("true",attr1.get("key1"));
assertEquals("false",attr1.get("key2"));
assertTrue(configAttributes.containsKey("attr2"));
Map attr2=configAttributes.get("attr2");
assertNotNull(attr2);
assertEquals(1,attr2.size());
assertEquals("15",attr2.get("key1"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hostIds=new ArrayList(){
{
add(host1Id);
}
}
;
List hostNames=new ArrayList(){
{
add("h1");
}
}
;
HostEntity hostEntity1=createMock(HostEntity.class);
expect(hostDAO.getHostNamesByHostIds(hostIds)).andReturn(hostNames).atLeastOnce();
expect(hostDAO.findByName("h1")).andReturn(hostEntity1).anyTimes();
expect(hostEntity1.getHostId()).andReturn(host1Id).anyTimes();
ConfigGroup configGroup1=createNiceMock(ConfigGroup.class);
ConfigGroup configGroup2=createNiceMock(ConfigGroup.class);
ConfigGroup configGroup3=createNiceMock(ConfigGroup.class);
ConfigGroup configGroup4=createNiceMock(ConfigGroup.class);
ConfigGroupResponse response1=createNiceMock(ConfigGroupResponse.class);
ConfigGroupResponse response2=createNiceMock(ConfigGroupResponse.class);
ConfigGroupResponse response3=createNiceMock(ConfigGroupResponse.class);
ConfigGroupResponse response4=createNiceMock(ConfigGroupResponse.class);
Map configGroupMap=new HashMap();
configGroupMap.put(1L,configGroup1);
configGroupMap.put(2L,configGroup2);
configGroupMap.put(3L,configGroup3);
configGroupMap.put(4L,configGroup4);
Map configGroupByHostname=new HashMap();
configGroupByHostname.put(4L,configGroup4);
expect(configGroup1.convertToResponse()).andReturn(response1).anyTimes();
expect(configGroup2.convertToResponse()).andReturn(response2).anyTimes();
expect(configGroup3.convertToResponse()).andReturn(response3).anyTimes();
expect(configGroup4.convertToResponse()).andReturn(response4).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(cluster.getConfigGroups()).andReturn(configGroupMap).anyTimes();
expect(cluster.getClusterName()).andReturn("Cluster100").anyTimes();
expect(configGroup1.getName()).andReturn("g1").anyTimes();
expect(configGroup2.getName()).andReturn("g2").anyTimes();
expect(configGroup3.getName()).andReturn("g3").anyTimes();
expect(configGroup4.getName()).andReturn("g4").anyTimes();
expect(configGroup1.getTag()).andReturn("t1").anyTimes();
expect(configGroup2.getTag()).andReturn("t2").anyTimes();
expect(configGroup3.getTag()).andReturn("t3").anyTimes();
expect(configGroup4.getTag()).andReturn("t4").anyTimes();
Map hostMap=new HashMap();
hostMap.put(host1Id,h1);
expect(configGroup4.getHosts()).andReturn(hostMap).anyTimes();
expect(response1.getClusterName()).andReturn("Cluster100").anyTimes();
expect(response2.getClusterName()).andReturn("Cluster100").anyTimes();
expect(response3.getClusterName()).andReturn("Cluster100").anyTimes();
expect(response4.getClusterName()).andReturn("Cluster100").anyTimes();
expect(response1.getId()).andReturn(1L).anyTimes();
expect(response2.getId()).andReturn(2L).anyTimes();
expect(response3.getId()).andReturn(3L).anyTimes();
expect(response4.getId()).andReturn(4L).anyTimes();
expect(response2.getGroupName()).andReturn("g2").anyTimes();
expect(response3.getTag()).andReturn("t3").anyTimes();
expect(cluster.getConfigGroupsByHostname("h1")).andReturn(configGroupByHostname).anyTimes();
Set> hostObj=new HashSet>();
Map hostnames=new HashMap();
hostnames.put("host_name","h1");
hostObj.add(hostnames);
expect(response4.getHosts()).andReturn(hostObj).anyTimes();
replay(managementController,clusters,cluster,hostDAO,hostEntity1,configGroup1,configGroup2,configGroup3,configGroup4,response1,response2,response3,response4);
ResourceProvider resourceProvider=getConfigGroupResourceProvider(managementController);
Set propertyIds=new HashSet();
propertyIds.add(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID);
propertyIds.add(ConfigGroupResourceProvider.CONFIGGROUP_ID_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=resourceProvider.getResources(request,predicate);
assertEquals(4,resources.size());
predicate=new PredicateBuilder().property(ConfigGroupResourceProvider.CONFIGGROUP_ID_PROPERTY_ID).equals(1L).and().property(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
resources=resourceProvider.getResources(request,predicate);
assertEquals(1,resources.size());
assertEquals(1L,resources.iterator().next().getPropertyValue(ConfigGroupResourceProvider.CONFIGGROUP_ID_PROPERTY_ID));
predicate=new PredicateBuilder().property(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ConfigGroupResourceProvider.CONFIGGROUP_NAME_PROPERTY_ID).equals("g2").toPredicate();
resources=resourceProvider.getResources(request,predicate);
assertEquals(1,resources.size());
assertEquals("g2",resources.iterator().next().getPropertyValue(ConfigGroupResourceProvider.CONFIGGROUP_NAME_PROPERTY_ID));
predicate=new PredicateBuilder().property(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ConfigGroupResourceProvider.CONFIGGROUP_TAG_PROPERTY_ID).equals("t3").toPredicate();
resources=resourceProvider.getResources(request,predicate);
assertEquals(1,resources.size());
assertEquals("t3",resources.iterator().next().getPropertyValue(ConfigGroupResourceProvider.CONFIGGROUP_TAG_PROPERTY_ID));
predicate=new PredicateBuilder().property(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ConfigGroupResourceProvider.CONFIGGROUP_HOSTS_PROPERTY_ID).equals("h1").toPredicate();
resources=resourceProvider.getResources(request,predicate);
assertEquals(1,resources.size());
Set> hostSet=(Set>)resources.iterator().next().getPropertyValue(ConfigGroupResourceProvider.CONFIGGROUP_HOSTS_PROPERTY_ID);
assertEquals("h1",hostSet.iterator().next().get(ConfigGroupResourceProvider.CONFIGGROUP_HOSTNAME_PROPERTY_ID));
predicate=new PredicateBuilder().property(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ConfigGroupResourceProvider.CONFIGGROUP_HOSTS_HOSTNAME_PROPERTY_ID).equals("h1").toPredicate();
resources=resourceProvider.getResources(request,predicate);
assertEquals(1,resources.size());
hostSet=(Set>)resources.iterator().next().getPropertyValue(ConfigGroupResourceProvider.CONFIGGROUP_HOSTS_PROPERTY_ID);
assertEquals("h1",hostSet.iterator().next().get(ConfigGroupResourceProvider.CONFIGGROUP_HOSTNAME_PROPERTY_ID));
predicate=new PredicateBuilder().property(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ConfigGroupResourceProvider.CONFIGGROUP_TAG_PROPERTY_ID).equals("t4").and().property(ConfigGroupResourceProvider.CONFIGGROUP_HOSTS_PROPERTY_ID).equals(host1Id).toPredicate();
resources=resourceProvider.getResources(request,predicate);
assertEquals(1,resources.size());
hostSet=(Set>)resources.iterator().next().getPropertyValue(ConfigGroupResourceProvider.CONFIGGROUP_HOSTS_PROPERTY_ID);
assertEquals("h1",hostSet.iterator().next().get(ConfigGroupResourceProvider.CONFIGGROUP_HOSTNAME_PROPERTY_ID));
predicate=new PredicateBuilder().property(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ConfigGroupResourceProvider.CONFIGGROUP_TAG_PROPERTY_ID).equals("t4").and().property(ConfigGroupResourceProvider.CONFIGGROUP_HOSTS_HOSTNAME_PROPERTY_ID).equals("h1").toPredicate();
resources=resourceProvider.getResources(request,predicate);
assertEquals(1,resources.size());
hostSet=(Set>)resources.iterator().next().getPropertyValue(ConfigGroupResourceProvider.CONFIGGROUP_HOSTS_PROPERTY_ID);
assertEquals("h1",hostSet.iterator().next().get(ConfigGroupResourceProvider.CONFIGGROUP_HOSTNAME_PROPERTY_ID));
predicate=new PredicateBuilder().property(ConfigGroupResourceProvider.CONFIGGROUP_ID_PROPERTY_ID).equals(11L).and().property(ConfigGroupResourceProvider.CONFIGGROUP_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
NoSuchResourceException resourceException=null;
try {
resourceProvider.getResources(request,predicate);
}
catch ( NoSuchResourceException ce) {
resourceException=ce;
}
Assert.assertNotNull(resourceException);
verify(managementController,clusters,cluster,hostDAO,hostEntity1,configGroup1,configGroup2,configGroup3,configGroup4,response1,response2,response3,response4);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.controller.internal.ConfigurationResourceProviderTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier allResponse=new HashSet();
allResponse.add(new ConfigurationResponse("Cluster100",stackId,"type","tag1",1L,null,null));
allResponse.add(new ConfigurationResponse("Cluster100",stackId,"type","tag2",2L,null,null));
allResponse.add(new ConfigurationResponse("Cluster100",stackId,"type","tag3",3L,null,null));
Set orResponse=new HashSet();
orResponse.add(new ConfigurationResponse("Cluster100",stackId,"type","tag1",1L,null,null));
orResponse.add(new ConfigurationResponse("Cluster100",stackId,"type","tag2",2L,null,null));
Capture> configRequestCapture1=new Capture>();
Capture> configRequestCapture2=new Capture>();
expect(managementController.getConfigurations(capture(configRequestCapture1))).andReturn(allResponse).once();
expect(managementController.getConfigurations(capture(configRequestCapture2))).andReturn(orResponse).once();
replay(managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(ConfigurationResourceProvider.CONFIGURATION_CLUSTER_NAME_PROPERTY_ID);
propertyIds.add(ConfigurationResourceProvider.CONFIGURATION_CONFIG_TAG_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(ConfigurationResourceProvider.CONFIGURATION_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Set setRequest=configRequestCapture1.getValue();
assertEquals(1,setRequest.size());
ConfigurationRequest configRequest=setRequest.iterator().next();
assertEquals("Cluster100",configRequest.getClusterName());
assertNull(configRequest.getType());
assertNull(configRequest.getVersionTag());
Assert.assertEquals(3,resources.size());
boolean containsResource1=false;
boolean containsResource2=false;
boolean containsResource3=false;
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(ConfigurationResourceProvider.CONFIGURATION_CLUSTER_NAME_PROPERTY_ID);
String stackIdProperty=(String)resource.getPropertyValue(ConfigurationResourceProvider.CONFIGURATION_STACK_ID_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
Assert.assertEquals(stackId.getStackId(),stackIdProperty);
String tag=(String)resource.getPropertyValue(ConfigurationResourceProvider.CONFIGURATION_CONFIG_TAG_PROPERTY_ID);
if (tag.equals("tag1")) {
containsResource1=true;
}
else if (tag.equals("tag2")) {
containsResource2=true;
}
else if (tag.equals("tag3")) {
containsResource3=true;
}
}
assertTrue(containsResource1);
assertTrue(containsResource2);
assertTrue(containsResource3);
predicate=new PredicateBuilder().property(ConfigurationResourceProvider.CONFIGURATION_CONFIG_TAG_PROPERTY_ID).equals("tag1").or().property(ConfigurationResourceProvider.CONFIGURATION_CONFIG_TAG_PROPERTY_ID).equals("tag2").toPredicate();
request=PropertyHelper.getReadRequest(propertyIds);
resources=provider.getResources(request,predicate);
setRequest=configRequestCapture2.getValue();
assertEquals(2,setRequest.size());
boolean containsTag1=false;
boolean containsTag2=false;
for ( ConfigurationRequest cr : setRequest) {
assertNull(cr.getClusterName());
if (cr.getVersionTag().equals("tag1")) {
containsTag1=true;
}
else if (cr.getVersionTag().equals("tag2")) {
containsTag2=true;
}
}
assertTrue(containsTag1);
assertTrue(containsTag2);
Assert.assertEquals(2,resources.size());
containsResource1=false;
containsResource2=false;
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(ConfigurationResourceProvider.CONFIGURATION_CLUSTER_NAME_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
String tag=(String)resource.getPropertyValue(ConfigurationResourceProvider.CONFIGURATION_CONFIG_TAG_PROPERTY_ID);
if (tag.equals("tag1")) {
containsResource1=true;
}
else if (tag.equals("tag2")) {
containsResource2=true;
}
}
assertTrue(containsResource1);
assertTrue(containsResource2);
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.CredentialResourceProviderTest TestInitializer InternalCallVerifier BooleanVerifier HybridVerifier Class: org.apache.ambari.server.controller.internal.ExportBlueprintRequestTest APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier clusterNode=new TreeNodeImpl(null,clusterResource,"cluster");
Resource configResource=new ResourceImpl(Resource.Type.Configuration);
clusterNode.addChild(configResource,"configurations");
Resource hostsResource=new ResourceImpl(Resource.Type.Host);
Resource host1Resource=new ResourceImpl(Resource.Type.Host);
Resource host2Resource=new ResourceImpl(Resource.Type.Host);
Resource host3Resource=new ResourceImpl(Resource.Type.Host);
TreeNode hostsNode=clusterNode.addChild(hostsResource,"hosts");
TreeNode host1Node=hostsNode.addChild(host1Resource,"host_1");
TreeNode host2Node=hostsNode.addChild(host2Resource,"host_2");
TreeNode host3Node=hostsNode.addChild(host3Resource,"host_3");
host1Resource.setProperty("Hosts/host_name","host1");
host2Resource.setProperty("Hosts/host_name","host2");
host3Resource.setProperty("Hosts/host_name","host3");
List host1ComponentsList=Arrays.asList("NAMENODE","HDFS_CLIENT","ZOOKEEPER_SERVER","SECONDARY_NAMENODE");
List host2ComponentsList=Arrays.asList("DATANODE","HDFS_CLIENT","ZOOKEEPER_SERVER");
List host3ComponentsList=Arrays.asList("DATANODE","HDFS_CLIENT","ZOOKEEPER_SERVER");
processHostGroupComponents(host1Node,host1ComponentsList);
processHostGroupComponents(host2Node,host2ComponentsList);
processHostGroupComponents(host3Node,host3ComponentsList);
ExportBlueprintRequest exportBlueprintRequest=new ExportBlueprintRequest(clusterNode);
assertEquals(CLUSTER_NAME,exportBlueprintRequest.getClusterName());
Blueprint bp=exportBlueprintRequest.getBlueprint();
assertEquals("exported-blueprint",bp.getName());
Map hostGroups=bp.getHostGroups();
assertEquals(2,hostGroups.size());
String hg1Name=null;
String hg2Name=null;
for ( HostGroup group : hostGroups.values()) {
Collection components=group.getComponentNames();
if (components.containsAll(host1ComponentsList)) {
assertEquals(host1ComponentsList.size(),components.size());
assertEquals("1",group.getCardinality());
hg1Name=group.getName();
}
else if (components.containsAll(host2ComponentsList)) {
assertEquals(host2ComponentsList.size(),components.size());
assertEquals("2",group.getCardinality());
hg2Name=group.getName();
}
else {
fail("Host group contained invalid components");
}
}
assertNotNull(hg1Name);
assertNotNull(hg2Name);
HostGroupInfo host1Info=exportBlueprintRequest.getHostGroupInfo().get(hg1Name);
assertEquals(1,host1Info.getHostNames().size());
assertEquals("host1",host1Info.getHostNames().iterator().next());
HostGroupInfo host2Info=exportBlueprintRequest.getHostGroupInfo().get(hg2Name);
assertEquals(2,host2Info.getHostNames().size());
assertTrue(host2Info.getHostNames().contains("host2") && host2Info.getHostNames().contains("host3"));
}
Class: org.apache.ambari.server.controller.internal.FeedResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier > propertySet=new HashSet>();
Map properties=new HashMap();
List feedNames=new LinkedList();
feedNames.add("Feed1");
feedNames.add("Feed2");
feedNames.add("Feed3");
Map props=new HashMap();
Feed feed1=new Feed("Feed1","d","s","sch","source","st","end","l","a","target","st","end","l","a",props);
Feed feed2=new Feed("Feed2","d","s","sch","source","st","end","l","a","target","st","end","l","a",props);
Feed feed3=new Feed("Feed3","d","s","sch","source","st","end","l","a","target","st","end","l","a",props);
expect(service.getFeedNames()).andReturn(feedNames);
expect(service.getFeed("Feed1")).andReturn(feed1);
expect(service.getFeed("Feed2")).andReturn(feed2);
expect(service.getFeed("Feed3")).andReturn(feed3);
replay(service);
propertySet.add(properties);
Request request=PropertyHelper.getCreateRequest(propertySet,Collections.emptyMap());
FeedResourceProvider provider=new FeedResourceProvider(service,PropertyHelper.getPropertyIds(Resource.Type.DRFeed),PropertyHelper.getKeyPropertyIds(Resource.Type.DRFeed));
Set resources=provider.getResources(request,null);
Assert.assertEquals(3,resources.size());
verify(service);
}
Class: org.apache.ambari.server.controller.internal.HostComponentProcessResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("status","RUNNING");
put("name","a1");
}
}
);
PredicateBuilder pb=new PredicateBuilder().property(HostComponentProcessResourceProvider.HC_PROCESS_CLUSTER_NAME_ID).equals("c1").and();
pb=pb.property(HostComponentProcessResourceProvider.HC_PROCESS_HOST_NAME_ID).equals("h1").and();
Predicate predicate=pb.property(HostComponentProcessResourceProvider.HC_PROCESS_COMPONENT_NAME_ID).equals("comp1").toPredicate();
Request request=PropertyHelper.getReadRequest(Collections.emptySet());
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(Integer.valueOf(1),Integer.valueOf(resources.size()));
Resource res=resources.iterator().next();
Assert.assertNotNull(res.getPropertyValue(HostComponentProcessResourceProvider.HC_PROCESS_NAME_ID));
Assert.assertNotNull(res.getPropertyValue(HostComponentProcessResourceProvider.HC_PROCESS_STATUS_ID));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("status","RUNNING");
put("name","a");
}
}
,new HashMap(){
{
put("status","RUNNING");
put("name","b");
}
}
,new HashMap(){
{
put("status","NOT_RUNNING");
put("name","c");
}
}
);
PredicateBuilder pb=new PredicateBuilder().property(HostComponentProcessResourceProvider.HC_PROCESS_CLUSTER_NAME_ID).equals("c1").and();
pb=pb.property(HostComponentProcessResourceProvider.HC_PROCESS_HOST_NAME_ID).equals("h1").and();
Predicate predicate=pb.property(HostComponentProcessResourceProvider.HC_PROCESS_COMPONENT_NAME_ID).equals("comp1").toPredicate();
Request request=PropertyHelper.getReadRequest(Collections.emptySet());
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(Integer.valueOf(3),Integer.valueOf(resources.size()));
for ( Resource r : resources) {
Assert.assertNotNull(r.getPropertyValue(HostComponentProcessResourceProvider.HC_PROCESS_NAME_ID));
Assert.assertNotNull(r.getPropertyValue(HostComponentProcessResourceProvider.HC_PROCESS_STATUS_ID));
}
}
InternalCallVerifier EqualityVerifier emptySet());
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(Integer.valueOf(0),Integer.valueOf(resources.size()));
}
Class: org.apache.ambari.server.controller.internal.HostComponentResourceProviderTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyIds=new HashSet();
propertyIds.add("foo");
propertyIds.add("cat1/foo");
propertyIds.add("cat2/bar");
propertyIds.add("cat2/baz");
propertyIds.add("cat3/sub1/bam");
propertyIds.add("cat4/sub2/sub3/bat");
propertyIds.add("cat5/subcat5/map");
Map keyPropertyIds=new HashMap();
AmbariManagementController managementController=createMock(AmbariManagementController.class);
Injector injector=createNiceMock(Injector.class);
HostComponentResourceProvider provider=new HostComponentResourceProvider(propertyIds,keyPropertyIds,managementController,injector);
Set unsupported=provider.checkPropertyIds(Collections.singleton("foo"));
Assert.assertTrue(unsupported.isEmpty());
Assert.assertTrue(provider.checkPropertyIds(Collections.singleton("cat5/subcat5/map/key")).isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("bar"));
Assert.assertEquals(1,unsupported.size());
Assert.assertTrue(unsupported.contains("bar"));
unsupported=provider.checkPropertyIds(Collections.singleton("cat1/foo"));
Assert.assertTrue(unsupported.isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("cat1"));
Assert.assertTrue(unsupported.isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("config"));
Assert.assertTrue(unsupported.isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("config/unknown_property"));
Assert.assertTrue(unsupported.isEmpty());
}
Class: org.apache.ambari.server.controller.internal.HostKerberosIdentityResourceProviderTest APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier identities=new ArrayList();
identities.add(identity1);
identities.add(identity2);
identities.add(identity3);
identities.add(identity4);
identities.add(identity5);
Map> activeIdentities=new HashMap>();
activeIdentities.put("Host100",identities);
KerberosHelper kerberosHelper=createStrictMock(KerberosHelper.class);
expect(kerberosHelper.getActiveIdentities("Cluster100","Host100",null,null,true)).andReturn(activeIdentities).times(1);
replayAll();
ResourceProvider provider=new HostKerberosIdentityResourceProvider(managementController);
Field field;
field=HostKerberosIdentityResourceProvider.class.getDeclaredField("kerberosHelper");
field.setAccessible(true);
field.set(provider,kerberosHelper);
field=HostKerberosIdentityResourceProvider.class.getDeclaredField("kerberosPrincipalDAO");
field.setAccessible(true);
field.set(provider,kerberosPrincipalDAO);
field=HostKerberosIdentityResourceProvider.class.getDeclaredField("kerberosPrincipalHostDAO");
field.setAccessible(true);
field.set(provider,kerberosPrincipalHostDAO);
field=HostKerberosIdentityResourceProvider.class.getDeclaredField("hostDAO");
field.setAccessible(true);
field.set(provider,hostDAO);
Set propertyIds=new HashSet();
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_CLUSTER_NAME_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_HOST_NAME_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_DESCRIPTION_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_NAME_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_TYPE_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_LOCAL_USERNAME_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_PATH_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_OWNER_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_OWNER_ACCESS_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_GROUP_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_GROUP_ACCESS_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_MODE_PROPERTY_ID);
propertyIds.add(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_INSTALLED_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_HOST_NAME_PROPERTY_ID).equals("Host100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(3,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("Cluster100",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_CLUSTER_NAME_PROPERTY_ID));
Assert.assertEquals("Host100",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_HOST_NAME_PROPERTY_ID));
String principal=(String)resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_NAME_PROPERTY_ID);
if ("principal1@EXAMPLE.COM".equals(principal)) {
Assert.assertEquals("identity1",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_DESCRIPTION_PROPERTY_ID));
Assert.assertEquals(KerberosPrincipalType.USER,resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_TYPE_PROPERTY_ID));
Assert.assertEquals("principal1",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_LOCAL_USERNAME_PROPERTY_ID));
Assert.assertEquals("/etc/security/keytabs/principal1.headless.keytab",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_PATH_PROPERTY_ID));
Assert.assertEquals("principal1",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_OWNER_PROPERTY_ID));
Assert.assertEquals("rw",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_OWNER_ACCESS_PROPERTY_ID));
Assert.assertEquals("principal1",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_GROUP_PROPERTY_ID));
Assert.assertEquals("r",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_GROUP_ACCESS_PROPERTY_ID));
Assert.assertEquals("640",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_MODE_PROPERTY_ID));
Assert.assertEquals("true",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_INSTALLED_PROPERTY_ID));
}
else if ("principal2/Host100@EXAMPLE.COM".equals(principal)) {
Assert.assertEquals("identity2",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_DESCRIPTION_PROPERTY_ID));
Assert.assertEquals(KerberosPrincipalType.SERVICE,resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_TYPE_PROPERTY_ID));
Assert.assertEquals("principal2",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_LOCAL_USERNAME_PROPERTY_ID));
Assert.assertNull(resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_PATH_PROPERTY_ID));
Assert.assertNull(resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_OWNER_PROPERTY_ID));
Assert.assertNull(resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_OWNER_ACCESS_PROPERTY_ID));
Assert.assertNull(resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_GROUP_PROPERTY_ID));
Assert.assertNull(resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_GROUP_ACCESS_PROPERTY_ID));
Assert.assertNull(resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_MODE_PROPERTY_ID));
Assert.assertEquals("false",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_INSTALLED_PROPERTY_ID));
}
else if ("principal5@EXAMPLE.COM".equals(principal)) {
Assert.assertEquals("identity5",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_DESCRIPTION_PROPERTY_ID));
Assert.assertEquals(KerberosPrincipalType.USER,resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_TYPE_PROPERTY_ID));
Assert.assertEquals("principal5",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_PRINCIPAL_LOCAL_USERNAME_PROPERTY_ID));
Assert.assertEquals("/etc/security/keytabs/principal5.headless.keytab",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_PATH_PROPERTY_ID));
Assert.assertEquals("principal5",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_OWNER_PROPERTY_ID));
Assert.assertEquals("r",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_OWNER_ACCESS_PROPERTY_ID));
Assert.assertEquals("hadoop",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_GROUP_PROPERTY_ID));
Assert.assertEquals("r",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_GROUP_ACCESS_PROPERTY_ID));
Assert.assertEquals("440",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_MODE_PROPERTY_ID));
Assert.assertEquals("unknown",resource.getPropertyValue(HostKerberosIdentityResourceProvider.KERBEROS_IDENTITY_KEYTAB_FILE_INSTALLED_PROPERTY_ID));
}
else {
Assert.fail("Unexpected principal: " + principal);
}
}
verifyAll();
}
Class: org.apache.ambari.server.controller.internal.HostResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier clusterSet=new HashSet();
clusterSet.add(cluster);
ServiceComponentHostResponse shr1=new ServiceComponentHostResponse("Cluster100","Service100","Component100","Host100","STARTED","",null,null,null);
ServiceComponentHostResponse shr2=new ServiceComponentHostResponse("Cluster100","Service100","Component102","Host100","INSTALLED","",null,null,null);
ServiceComponentHostResponse shr3=new ServiceComponentHostResponse("Cluster100","Service100","Component103","Host100","STARTED","",null,null,null);
Set responses=new HashSet();
responses.add(shr1);
responses.add(shr2);
responses.add(shr3);
expect(host100.getMaintenanceState(2)).andReturn(MaintenanceState.OFF).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getHostComponents(EasyMock.>anyObject())).andReturn(responses).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(clusters.getClustersForHost("Host100")).andReturn(clusterSet).anyTimes();
expect(clusters.getHosts()).andReturn(Arrays.asList(host100)).anyTimes();
expect(cluster.getClusterId()).andReturn(2L).anyTimes();
expect(hostResponse1.getClusterName()).andReturn("Cluster100").anyTimes();
expect(hostResponse1.getHostname()).andReturn("Host100").anyTimes();
expect(hostResponse1.getHealthStatus()).andReturn(healthStatus).anyTimes();
expect(hostResponse1.getStatus()).andReturn(HealthStatus.UNHEALTHY.name()).anyTimes();
expect(healthStatus.getHealthStatus()).andReturn(HostHealthStatus.HealthStatus.HEALTHY).anyTimes();
expect(healthStatus.getHealthReport()).andReturn("HEALTHY").anyTimes();
expect(ambariMetaInfo.getComponent((String)anyObject(),(String)anyObject(),(String)anyObject(),(String)anyObject())).andReturn(componentInfo).anyTimes();
expect(componentInfo.getCategory()).andReturn("MASTER").anyTimes();
expect(resourceProviderFactory.getHostResourceProvider(EasyMock.>anyObject(),EasyMock.>anyObject(),eq(managementController))).andReturn(hostResourceProvider).anyTimes();
Set propertyIds=new HashSet();
propertyIds.add(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
replayAll();
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
String status=(String)resource.getPropertyValue(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Assert.assertEquals("UNHEALTHY",status);
}
verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier clusterSet=new HashSet();
clusterSet.add(cluster);
ServiceComponentHostResponse shr1=new ServiceComponentHostResponse("Cluster100","Service100","Component100","Host100","STARTED","",null,null,null);
ServiceComponentHostResponse shr2=new ServiceComponentHostResponse("Cluster100","Service100","Component102","Host100","INSTALLED","",null,null,null);
ServiceComponentHostResponse shr3=new ServiceComponentHostResponse("Cluster100","Service100","Component103","Host100","STARTED","",null,null,null);
Set responses=new HashSet();
responses.add(shr1);
responses.add(shr2);
responses.add(shr3);
expect(host100.getMaintenanceState(2)).andReturn(MaintenanceState.OFF).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getHostComponents(EasyMock.>anyObject())).andReturn(responses).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(clusters.getClustersForHost("Host100")).andReturn(clusterSet).anyTimes();
expect(clusters.getHosts()).andReturn(Arrays.asList(host100)).anyTimes();
expect(cluster.getClusterId()).andReturn(2L).anyTimes();
expect(hostResponse1.getClusterName()).andReturn("Cluster100").anyTimes();
expect(hostResponse1.getHostname()).andReturn("Host100").anyTimes();
expect(hostResponse1.getHealthStatus()).andReturn(healthStatus).anyTimes();
expect(hostResponse1.getStatus()).andReturn(HealthStatus.ALERT.name()).anyTimes();
expect(healthStatus.getHealthStatus()).andReturn(HostHealthStatus.HealthStatus.HEALTHY).anyTimes();
expect(healthStatus.getHealthReport()).andReturn("HEALTHY").anyTimes();
expect(ambariMetaInfo.getComponent((String)anyObject(),(String)anyObject(),(String)anyObject(),(String)anyObject())).andReturn(componentInfo).anyTimes();
expect(componentInfo.getCategory()).andReturn("SLAVE").anyTimes();
expect(resourceProviderFactory.getHostResourceProvider(EasyMock.>anyObject(),EasyMock.>anyObject(),eq(managementController))).andReturn(hostResourceProvider).anyTimes();
Set propertyIds=new HashSet();
propertyIds.add(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
replayAll();
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
String status=(String)resource.getPropertyValue(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Assert.assertEquals("ALERT",status);
}
verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier clusterSet=new HashSet();
clusterSet.add(cluster);
ServiceComponentHostResponse shr1=new ServiceComponentHostResponse("Cluster100","Service100","Component100","Host100","STARTED","",null,null,null);
ServiceComponentHostResponse shr2=new ServiceComponentHostResponse("Cluster100","Service100","Component102","Host100","STARTED","",null,null,null);
ServiceComponentHostResponse shr3=new ServiceComponentHostResponse("Cluster100","Service100","Component103","Host100","STARTED","",null,null,null);
Set responses=new HashSet();
responses.add(shr1);
responses.add(shr2);
responses.add(shr3);
expect(host100.getMaintenanceState(2)).andReturn(MaintenanceState.OFF).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getHostComponents(EasyMock.>anyObject())).andReturn(responses).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(clusters.getClustersForHost("Host100")).andReturn(clusterSet).anyTimes();
expect(clusters.getHosts()).andReturn(Arrays.asList(host100)).anyTimes();
expect(cluster.getClusterId()).andReturn(2L).anyTimes();
expect(hostResponse1.getClusterName()).andReturn("").anyTimes();
expect(hostResponse1.getHostname()).andReturn("Host100").anyTimes();
expect(hostResponse1.getHealthStatus()).andReturn(healthStatus).anyTimes();
expect(hostResponse1.getStatus()).andReturn(HealthStatus.HEALTHY.name()).anyTimes();
expect(healthStatus.getHealthStatus()).andReturn(HostHealthStatus.HealthStatus.HEALTHY).anyTimes();
expect(healthStatus.getHealthReport()).andReturn("HEALTHY").anyTimes();
expect(ambariMetaInfo.getComponent((String)anyObject(),(String)anyObject(),(String)anyObject(),(String)anyObject())).andReturn(componentInfo).anyTimes();
expect(componentInfo.getCategory()).andReturn("MASTER").anyTimes();
expect(resourceProviderFactory.getHostResourceProvider(EasyMock.>anyObject(),EasyMock.>anyObject(),eq(managementController))).andReturn(hostResourceProvider).anyTimes();
Set propertyIds=new HashSet();
propertyIds.add(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
replayAll();
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
String status=(String)resource.getPropertyValue(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Assert.assertEquals("HEALTHY",status);
}
verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier clusterSet=new HashSet();
clusterSet.add(cluster);
ServiceComponentHostResponse shr1=new ServiceComponentHostResponse("Cluster100","Service100","Component100","Host100","STARTED","",null,null,null);
ServiceComponentHostResponse shr2=new ServiceComponentHostResponse("Cluster100","Service100","Component102","Host100","STARTED","",null,null,null);
ServiceComponentHostResponse shr3=new ServiceComponentHostResponse("Cluster100","Service100","Component103","Host100","STARTED","",null,null,null);
Set responses=new HashSet();
responses.add(shr1);
responses.add(shr2);
responses.add(shr3);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getHostComponents(EasyMock.>anyObject())).andReturn(responses).anyTimes();
expect(host100.getMaintenanceState(2)).andReturn(MaintenanceState.OFF).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(clusters.getClustersForHost("Host100")).andReturn(clusterSet).anyTimes();
expect(clusters.getHosts()).andReturn(Arrays.asList(host100)).anyTimes();
expect(cluster.getClusterId()).andReturn(2L).anyTimes();
expect(healthStatus.getHealthStatus()).andReturn(HostHealthStatus.HealthStatus.HEALTHY).anyTimes();
expect(healthStatus.getHealthReport()).andReturn("HEALTHY").anyTimes();
expect(ambariMetaInfo.getComponent((String)anyObject(),(String)anyObject(),(String)anyObject(),(String)anyObject())).andReturn(componentInfo).anyTimes();
expect(componentInfo.getCategory()).andReturn("MASTER").anyTimes();
expect(resourceProviderFactory.getHostResourceProvider(EasyMock.>anyObject(),EasyMock.>anyObject(),eq(managementController))).andReturn(hostResourceProvider).anyTimes();
Set propertyIds=new HashSet();
propertyIds.add(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
replayAll();
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
String status=(String)resource.getPropertyValue(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Assert.assertEquals("HEALTHY",status);
}
verifyAll();
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier emptyMap());
HostRequest request2=new HostRequest("host2","cluster1",Collections.emptyMap());
HostRequest request3=new HostRequest("host3","cluster1",Collections.emptyMap());
HostRequest request4=new HostRequest("host4","cluster1",Collections.emptyMap());
Set setRequests=new HashSet();
setRequests.add(request1);
setRequests.add(request2);
setRequests.add(request3);
setRequests.add(request4);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster("cluster1")).andReturn(cluster).times(4);
expect(clusters.getHost("host1")).andReturn(host1);
expect(host1.getHostName()).andReturn("host1").anyTimes();
expect(clusters.getClustersForHost("host1")).andReturn(Collections.singleton(cluster));
expect(host1.convertToResponse()).andReturn(response);
response.setClusterName("cluster1");
expect(clusters.getHost("host2")).andReturn(host2);
expect(host2.getHostName()).andReturn("host2").anyTimes();
expect(clusters.getClustersForHost("host2")).andReturn(Collections.singleton(cluster));
expect(host2.convertToResponse()).andReturn(response2);
response2.setClusterName("cluster1");
expect(clusters.getHost("host3")).andThrow(new HostNotFoundException("host3"));
expect(clusters.getHost("host4")).andThrow(new HostNotFoundException("host4"));
expect(cluster.getClusterId()).andReturn(2L).anyTimes();
replayAll();
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
Set setResponses=getHosts(managementController,setRequests);
assertEquals(2,setResponses.size());
assertTrue(setResponses.contains(response));
assertTrue(setResponses.contains(response2));
verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier clusterSet=new HashSet();
clusterSet.add(cluster);
expect(host100.getMaintenanceState(2)).andReturn(MaintenanceState.OFF).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(clusters.getClustersForHost("Host100")).andReturn(clusterSet).anyTimes();
expect(clusters.getHosts()).andReturn(Arrays.asList(host100)).anyTimes();
expect(cluster.getClusterId()).andReturn(2L).anyTimes();
expect(hostResponse1.getClusterName()).andReturn("Cluster100").anyTimes();
expect(hostResponse1.getHostname()).andReturn("Host100").anyTimes();
expect(hostResponse1.getHealthStatus()).andReturn(healthStatus).anyTimes();
expect(hostResponse1.getStatus()).andReturn(HealthStatus.UNKNOWN.name()).anyTimes();
expect(healthStatus.getHealthStatus()).andReturn(HostHealthStatus.HealthStatus.UNKNOWN).anyTimes();
expect(healthStatus.getHealthReport()).andReturn("UNKNOWN").anyTimes();
expect(resourceProviderFactory.getHostResourceProvider(EasyMock.>anyObject(),EasyMock.>anyObject(),eq(managementController))).andReturn(hostResourceProvider).anyTimes();
Set propertyIds=new HashSet();
propertyIds.add(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_NAME_PROPERTY_ID);
propertyIds.add(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
replayAll();
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(HostResourceProvider.HOST_CLUSTER_NAME_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
String status=(String)resource.getPropertyValue(HostResourceProvider.HOST_HOST_STATUS_PROPERTY_ID);
Assert.assertEquals("UNKNOWN",status);
}
verifyAll();
}
Class: org.apache.ambari.server.controller.internal.HttpPropertyProviderTest InternalCallVerifier BooleanVerifier map=new HashMap();
map.put("yarn.http.policy","HTTPS_ONLY");
map.put("yarn.resourcemanager.webapp.https.address","ec2-54-234-33-50.compute-1.amazonaws.com:8999");
map.put("yarn.resourcemanager.webapp.address","ec2-54-234-33-50.compute-1.amazonaws.com:8088");
expect(injector.getInstance(Clusters.class)).andReturn(clusters);
expect(clusters.getCluster("testCluster")).andReturn(cluster);
expect(cluster.getDesiredConfigByType("yarn-site")).andReturn(config1).anyTimes();
expect(cluster.getDesiredConfigByType("core-site")).andReturn(config2).anyTimes();
expect(config1.getProperties()).andReturn(map).anyTimes();
expect(config2.getProperties()).andReturn(new HashMap()).anyTimes();
replay(injector,clusters,cluster,config1,config2);
HttpProxyPropertyProvider propProvider=new HttpProxyPropertyProvider(streamProvider,configuration,injector,PROPERTY_ID_CLUSTER_NAME,PROPERTY_ID_HOST_NAME,PROPERTY_ID_COMPONENT_NAME);
Resource resource=new ResourceImpl(Resource.Type.HostComponent);
resource.setProperty(PROPERTY_ID_HOST_NAME,"ec2-54-234-33-50.compute-1.amazonaws.com");
resource.setProperty(PROPERTY_ID_CLUSTER_NAME,"testCluster");
resource.setProperty(PROPERTY_ID_COMPONENT_NAME,"RESOURCEMANAGER");
Request request=PropertyHelper.getReadRequest(Collections.emptySet());
propProvider.populateResources(Collections.singleton(resource),request,null);
Assert.assertTrue(resource.getPropertiesMap().get("HostRoles").get("ha_state").equals("ACTIVE"));
Assert.assertTrue(streamProvider.getLastSpec().equals("https://ec2-54-234-33-50.compute-1.amazonaws.com:8999" + "/ws/v1/cluster/info"));
}
InternalCallVerifier BooleanVerifier map=new HashMap();
map.put("yarn.http.policy","HTTPS_ONLY");
map.put("yarn.resourcemanager.ha.rm-ids","rm1,rm2");
map.put("yarn.resourcemanager.hostname.rm1","lc6402.ambari.apache.org");
map.put("yarn.resourcemanager.hostname.rm2","lc6403.ambari.apache.org");
map.put("yarn.resourcemanager.webapp.address.rm1","lc6402.ambari.apache.org:8099");
map.put("yarn.resourcemanager.webapp.address.rm2","lc6403.ambari.apache.org:8099");
map.put("yarn.resourcemanager.webapp.https.address.rm1","lc6402.ambari.apache.org:8066");
map.put("yarn.resourcemanager.webapp.https.address.rm2","lc6403.ambari.apache.org:8066");
expect(injector.getInstance(Clusters.class)).andReturn(clusters);
expect(clusters.getCluster("testCluster")).andReturn(cluster);
expect(cluster.getDesiredConfigByType("yarn-site")).andReturn(config1).anyTimes();
expect(cluster.getDesiredConfigByType("core-site")).andReturn(config2).anyTimes();
expect(config1.getProperties()).andReturn(map).anyTimes();
expect(config2.getProperties()).andReturn(new HashMap()).anyTimes();
replay(injector,clusters,cluster,config1,config2);
HttpProxyPropertyProvider propProvider=new HttpProxyPropertyProvider(streamProvider,configuration,injector,PROPERTY_ID_CLUSTER_NAME,PROPERTY_ID_HOST_NAME,PROPERTY_ID_COMPONENT_NAME);
Resource resource=new ResourceImpl(Resource.Type.HostComponent);
resource.setProperty(PROPERTY_ID_HOST_NAME,"lc6402.ambari.apache.org");
resource.setProperty(PROPERTY_ID_CLUSTER_NAME,"testCluster");
resource.setProperty(PROPERTY_ID_COMPONENT_NAME,"RESOURCEMANAGER");
Request request=PropertyHelper.getReadRequest(Collections.emptySet());
propProvider.populateResources(Collections.singleton(resource),request,null);
Assert.assertTrue(resource.getPropertiesMap().get("HostRoles").get("ha_state").equals("ACTIVE"));
Assert.assertTrue(streamProvider.getLastSpec().equals("https://lc6402.ambari.apache.org:8066" + "/ws/v1/cluster/info"));
}
Class: org.apache.ambari.server.controller.internal.InstanceResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier > propertySet=new HashSet>();
Map properties=new HashMap();
List instances=new LinkedList();
Instance instance1=new Instance("Feed1","Instance1","s","st","et","d","l");
Instance instance2=new Instance("Feed1","Instance2","s","st","et","d","l");
Instance instance3=new Instance("Feed1","Instance3","s","st","et","d","l");
instances.add(instance1);
instances.add(instance2);
instances.add(instance3);
expect(service.getFeedNames()).andReturn(Collections.singletonList("Feed1"));
expect(service.getInstances("Feed1")).andReturn(instances);
replay(service);
propertySet.add(properties);
Request request=PropertyHelper.getCreateRequest(propertySet,Collections.emptyMap());
InstanceResourceProvider provider=new InstanceResourceProvider(service,PropertyHelper.getPropertyIds(Resource.Type.DRInstance),PropertyHelper.getKeyPropertyIds(Resource.Type.DRInstance));
Set resources=provider.getResources(request,null);
Assert.assertEquals(3,resources.size());
verify(service);
}
Class: org.apache.ambari.server.controller.internal.JMXHostProviderTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier yarnConfigs=new HashMap();
yarnConfigs.put(RESOURCEMANAGER_PORT,"localhost:50030");
yarnConfigs.put(NODEMANAGER_PORT,"localhost:11111");
ConfigurationRequest cr2=new ConfigurationRequest("c1","yarn-site","versionN+1",yarnConfigs,null);
ClusterRequest crReq=new ClusterRequest(1L,"c1",null,null);
crReq.setDesiredConfig(Collections.singletonList(cr2));
controller.updateClusters(Collections.singleton(crReq),null);
Assert.assertEquals("50030",providerModule.getPort("c1","RESOURCEMANAGER","localhost"));
Assert.assertEquals("11111",providerModule.getPort("c1","NODEMANAGER","localhost"));
Assert.assertEquals("70070",providerModule.getPort("c1","NAMENODE","localhost"));
Assert.assertEquals(null,providerModule.getPort("c1","JOBTRACKER","localhost"));
}
InternalCallVerifier BooleanVerifier hostComponents=new HashMap();
hostComponents.put("host1",null);
expect(managementControllerMock.getClusters()).andReturn(clustersMock).anyTimes();
expect(managementControllerMock.findServiceName(clusterMock,"DATANODE")).andReturn("HDFS");
expect(clustersMock.getCluster("c1")).andReturn(clusterMock).anyTimes();
expect(clusterMock.getService("HDFS")).andReturn(serviceMock).anyTimes();
expect(serviceMock.getServiceComponent("DATANODE")).andReturn(serviceComponentMock).anyTimes();
expect(serviceComponentMock.getServiceComponentHosts()).andReturn(hostComponents).anyTimes();
replay(managementControllerMock,clustersMock,clusterMock,serviceMock,serviceComponentMock);
providerModule.managementController=managementControllerMock;
Set result=providerModule.getHostNames("c1","DATANODE");
Assert.assertTrue(result.iterator().next().equals("host1"));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.internal.JobResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier requestedIds=new HashSet();
requestedIds.add(JobResourceProvider.JOB_ID_PROPERTY_ID);
requestedIds.add(JobResourceProvider.JOB_SUBMIT_TIME_PROPERTY_ID);
requestedIds.add(JobResourceProvider.JOB_ELAPSED_TIME_PROPERTY_ID);
Map keyPropertyIds=PropertyHelper.getKeyPropertyIds(Resource.Type.Job);
ResourceProvider provider=new TestJobResourceProvider(requestedIds,keyPropertyIds,4);
Request request=PropertyHelper.getReadRequest(requestedIds);
Predicate predicate=new PredicateBuilder().property(JobResourceProvider.JOB_ID_PROPERTY_ID).equals("job1").toPredicate();
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String workflowId=(String)resource.getPropertyValue(JobResourceProvider.JOB_ID_PROPERTY_ID);
Assert.assertEquals("job1",workflowId);
Assert.assertEquals(42l,resource.getPropertyValue(JobResourceProvider.JOB_SUBMIT_TIME_PROPERTY_ID));
Assert.assertEquals(0l,resource.getPropertyValue(JobResourceProvider.JOB_ELAPSED_TIME_PROPERTY_ID));
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier requestedIds=new HashSet();
requestedIds.add(JobResourceProvider.JOB_ID_PROPERTY_ID);
Map keyPropertyIds=PropertyHelper.getKeyPropertyIds(Resource.Type.Job);
ResourceProvider provider=new TestJobResourceProvider(requestedIds,keyPropertyIds,1);
Request request=PropertyHelper.getReadRequest(requestedIds);
Predicate predicate=new PredicateBuilder().property(JobResourceProvider.JOB_ID_PROPERTY_ID).equals("job1").toPredicate();
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String workflowId=(String)resource.getPropertyValue(JobResourceProvider.JOB_ID_PROPERTY_ID);
Assert.assertEquals("job1",workflowId);
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier requestedIds=new HashSet();
requestedIds.add(JobResourceProvider.JOB_ID_PROPERTY_ID);
requestedIds.add(JobResourceProvider.JOB_ELAPSED_TIME_PROPERTY_ID);
Map keyPropertyIds=PropertyHelper.getKeyPropertyIds(Resource.Type.Job);
ResourceProvider provider=new TestJobResourceProvider(requestedIds,keyPropertyIds,3);
Request request=PropertyHelper.getReadRequest(requestedIds);
Predicate predicate=new PredicateBuilder().property(JobResourceProvider.JOB_ID_PROPERTY_ID).equals("job1").toPredicate();
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String workflowId=(String)resource.getPropertyValue(JobResourceProvider.JOB_ID_PROPERTY_ID);
Assert.assertEquals("job1",workflowId);
Assert.assertEquals(1l,resource.getPropertyValue(JobResourceProvider.JOB_ELAPSED_TIME_PROPERTY_ID));
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier requestedIds=new HashSet();
requestedIds.add(JobResourceProvider.JOB_ID_PROPERTY_ID);
requestedIds.add(JobResourceProvider.JOB_SUBMIT_TIME_PROPERTY_ID);
Map keyPropertyIds=PropertyHelper.getKeyPropertyIds(Resource.Type.Job);
ResourceProvider provider=new TestJobResourceProvider(requestedIds,keyPropertyIds,2);
Request request=PropertyHelper.getReadRequest(requestedIds);
Predicate predicate=new PredicateBuilder().property(JobResourceProvider.JOB_ID_PROPERTY_ID).equals("job1").toPredicate();
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String workflowId=(String)resource.getPropertyValue(JobResourceProvider.JOB_ID_PROPERTY_ID);
Assert.assertEquals("job1",workflowId);
Assert.assertEquals(42l,resource.getPropertyValue(JobResourceProvider.JOB_SUBMIT_TIME_PROPERTY_ID));
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier expected=new HashSet();
expected.add(createJobResponse("Cluster100","workflow1","job1"));
expected.add(createJobResponse("Cluster100","workflow2","job2"));
expected.add(createJobResponse("Cluster100","workflow2","job3"));
Resource.Type type=Resource.Type.Job;
Set propertyIds=PropertyHelper.getPropertyIds(type);
JobFetcher jobFetcher=createMock(JobFetcher.class);
expect(jobFetcher.fetchJobDetails(propertyIds,null,"workflow2",null)).andReturn(expected).once();
replay(jobFetcher);
Map keyPropertyIds=PropertyHelper.getKeyPropertyIds(type);
ResourceProvider provider=new JobResourceProvider(propertyIds,keyPropertyIds,jobFetcher);
Request request=PropertyHelper.getReadRequest(propertyIds);
Predicate predicate=new PredicateBuilder().property(JobResourceProvider.JOB_WORKFLOW_ID_PROPERTY_ID).equals("workflow2").toPredicate();
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(3,resources.size());
Set names=new HashSet();
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(JobResourceProvider.JOB_CLUSTER_NAME_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
names.add((String)resource.getPropertyValue(JobResourceProvider.JOB_ID_PROPERTY_ID));
}
for ( Resource resource : expected) {
Assert.assertTrue(names.contains(resource.getPropertyValue(JobResourceProvider.JOB_ID_PROPERTY_ID)));
}
verify(jobFetcher);
}
Class: org.apache.ambari.server.controller.internal.KerberosDescriptorResourceProviderTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier entityCapture=EasyMock.newCapture();
kerberosDescriptorDAO.create(capture(entityCapture));
EasyMock.replay(request,kerberosDescriptorFactory,kerberosDescriptorDAO);
kerberosDescriptorResourceProvider.createResources(request);
Assert.assertNotNull(entityCapture.getValue());
Assert.assertEquals("The resource name is invalid!",TEST_KERBEROS_DESCRIPTOR_NAME,entityCapture.getValue().getName());
}
Class: org.apache.ambari.server.controller.internal.LdapSyncEventResourceProviderTest InternalCallVerifier EqualityVerifier > properties=new HashSet>();
Map propertyMap=new HashMap();
Set> specs=new HashSet>();
propertyMap.put(LdapSyncEventResourceProvider.EVENT_SPECS_PROPERTY_ID,specs);
properties.add(propertyMap);
provider.createResources(PropertyHelper.getCreateRequest(properties,null));
Set resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
}
InternalCallVerifier EqualityVerifier > properties=new HashSet>();
Map propertyMap=new HashMap();
Set> specs=new HashSet>();
propertyMap.put(LdapSyncEventResourceProvider.EVENT_SPECS_PROPERTY_ID,specs);
properties.add(propertyMap);
provider.createResources(PropertyHelper.getCreateRequest(properties,null));
Set resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
}
InternalCallVerifier EqualityVerifier > properties=new HashSet>();
Map propertyMap=new HashMap();
Set> specs=new HashSet>();
propertyMap.put(LdapSyncEventResourceProvider.EVENT_SPECS_PROPERTY_ID,specs);
properties.add(propertyMap);
provider.createResources(PropertyHelper.getCreateRequest(properties,null));
Set resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
provider.deleteResources(null);
resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(0,resources.size());
}
Class: org.apache.ambari.server.controller.internal.PageRequestImplTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.internal.PermissionResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier permissionEntities=new LinkedList();
PermissionEntity permissionEntity=createNiceMock(PermissionEntity.class);
ResourceTypeEntity resourceTypeEntity=createNiceMock(ResourceTypeEntity.class);
permissionEntities.add(permissionEntity);
expect(dao.findAll()).andReturn(permissionEntities);
expect(permissionEntity.getId()).andReturn(99);
expect(permissionEntity.getPermissionName()).andReturn("AMBARI.ADMINISTRATOR");
expect(permissionEntity.getPermissionLabel()).andReturn("Administrator");
expect(permissionEntity.getResourceType()).andReturn(resourceTypeEntity);
expect(resourceTypeEntity.getName()).andReturn("AMBARI");
replay(dao,permissionEntity,resourceTypeEntity);
PermissionResourceProvider provider=new PermissionResourceProvider();
Set resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals(99,resource.getPropertyValue(PermissionResourceProvider.PERMISSION_ID_PROPERTY_ID));
Assert.assertEquals("AMBARI.ADMINISTRATOR",resource.getPropertyValue(PermissionResourceProvider.PERMISSION_NAME_PROPERTY_ID));
Assert.assertEquals("Administrator",resource.getPropertyValue(PermissionResourceProvider.PERMISSION_LABEL_PROPERTY_ID));
Assert.assertEquals("AMBARI",resource.getPropertyValue(PermissionResourceProvider.RESOURCE_NAME_PROPERTY_ID));
verify(dao,permissionEntity,resourceTypeEntity);
}
Class: org.apache.ambari.server.controller.internal.PropertyPredicateVisitorTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier properties=visitor.getProperties();
Assert.assertEquals(1,properties.size());
Assert.assertEquals("Monkey",properties.get(PROPERTY_A));
visitor=new PropertyPredicateVisitor();
PredicateHelper.visit(PREDICATE_3,visitor);
properties=visitor.getProperties();
Assert.assertEquals(2,properties.size());
Assert.assertEquals("Monkey",properties.get(PROPERTY_A));
Assert.assertEquals("Runner",properties.get(PROPERTY_B));
visitor=new PropertyPredicateVisitor();
PredicateHelper.visit(PREDICATE_4,visitor);
properties=visitor.getProperties();
Assert.assertEquals(2,properties.size());
Assert.assertEquals("Monkey",properties.get(PROPERTY_A));
Assert.assertEquals("Runner",properties.get(PROPERTY_B));
visitor=new PropertyPredicateVisitor();
PredicateHelper.visit(PREDICATE_5,visitor);
properties=visitor.getProperties();
Assert.assertTrue(properties.isEmpty());
}
Class: org.apache.ambari.server.controller.internal.ProvisionClusterRequestTest APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier properties=createBlueprintRequestProperties(CLUSTER_NAME,BLUEPRINT_NAME);
ProvisionClusterRequest provisionClusterRequest=new ProvisionClusterRequest(properties,null);
assertEquals(CLUSTER_NAME,provisionClusterRequest.getClusterName());
assertEquals(TopologyRequest.Type.PROVISION,provisionClusterRequest.getType());
assertEquals(String.format("Provision Cluster '%s'",CLUSTER_NAME),provisionClusterRequest.getDescription());
assertSame(blueprint,provisionClusterRequest.getBlueprint());
Map hostGroupInfo=provisionClusterRequest.getHostGroupInfo();
assertEquals(2,hostGroupInfo.size());
assertEquals(1,provisionClusterRequest.getTopologyValidators().size());
HostGroupInfo group1Info=hostGroupInfo.get("group1");
assertEquals("group1",group1Info.getHostGroupName());
assertEquals(1,group1Info.getHostNames().size());
assertTrue(group1Info.getHostNames().contains("host1.myDomain.com"));
assertEquals(1,group1Info.getRequestedHostCount());
assertNull(group1Info.getPredicate());
Configuration group1Configuration=group1Info.getConfiguration();
assertNull(group1Configuration.getParentConfiguration());
assertEquals(1,group1Configuration.getProperties().size());
Map group1TypeProperties=group1Configuration.getProperties().get("foo-type");
assertEquals(2,group1TypeProperties.size());
assertEquals("prop1Value",group1TypeProperties.get("hostGroup1Prop1"));
assertEquals("prop2Value",group1TypeProperties.get("hostGroup1Prop2"));
assertTrue(group1Configuration.getAttributes().isEmpty());
HostGroupInfo group2Info=hostGroupInfo.get("group2");
assertEquals("group2",group2Info.getHostGroupName());
assertTrue(group2Info.getHostNames().isEmpty());
assertEquals(5,group2Info.getRequestedHostCount());
assertNotNull(group2Info.getPredicate());
Configuration group2Configuration=group2Info.getConfiguration();
assertNull(group2Configuration.getParentConfiguration());
assertEquals(1,group2Configuration.getProperties().size());
Map group2TypeProperties=group2Configuration.getProperties().get("foo-type");
assertEquals(1,group2TypeProperties.size());
assertEquals("prop1Value",group2TypeProperties.get("hostGroup2Prop1"));
Map>> group2Attributes=group2Configuration.getAttributes();
assertEquals(1,group2Attributes.size());
Map> group2Type1Attributes=group2Attributes.get("foo-type");
assertEquals(1,group2Type1Attributes.size());
Map group2Type1Prop1Attributes=group2Type1Attributes.get("hostGroup2Prop10");
assertEquals(1,group2Type1Prop1Attributes.size());
assertEquals("attribute1Prop10-value",group2Type1Prop1Attributes.get("attribute1"));
Configuration clusterScopeConfiguration=provisionClusterRequest.getConfiguration();
assertSame(blueprintConfig,clusterScopeConfiguration.getParentConfiguration());
assertEquals(1,clusterScopeConfiguration.getProperties().size());
Map clusterScopedProperties=clusterScopeConfiguration.getProperties().get("someType");
assertEquals(1,clusterScopedProperties.size());
assertEquals("someValue",clusterScopedProperties.get("property1"));
Map>> clusterScopedAttributes=clusterScopeConfiguration.getAttributes();
assertEquals(1,clusterScopedAttributes.size());
Map> clusterScopedTypeAttributes=clusterScopedAttributes.get("someType");
assertEquals(1,clusterScopedTypeAttributes.size());
Map clusterScopedTypePropertyAttributes=clusterScopedTypeAttributes.get("property1");
assertEquals(1,clusterScopedTypePropertyAttributes.size());
assertEquals("someAttributePropValue",clusterScopedTypePropertyAttributes.get("attribute1"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier properties=createBlueprintRequestProperties(CLUSTER_NAME,BLUEPRINT_NAME);
HashMap credentialHashMap=new HashMap<>();
credentialHashMap.put("alias","testAlias");
credentialHashMap.put("principal","testPrincipal");
credentialHashMap.put("key","testKey");
credentialHashMap.put("type","temporary");
Set> credentialsSet=new HashSet<>();
credentialsSet.add(credentialHashMap);
properties.put("credentials",credentialsSet);
ProvisionClusterRequest provisionClusterRequest=new ProvisionClusterRequest(properties,null);
assertEquals(provisionClusterRequest.getCredentialsMap().get("testAlias").getAlias(),"testAlias");
assertEquals(provisionClusterRequest.getCredentialsMap().get("testAlias").getPrincipal(),"testPrincipal");
assertEquals(provisionClusterRequest.getCredentialsMap().get("testAlias").getKey(),"testKey");
assertEquals(provisionClusterRequest.getCredentialsMap().get("testAlias").getType().name(),"TEMPORARY");
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier properties=createBlueprintRequestPropertiesCountOnly(CLUSTER_NAME,BLUEPRINT_NAME);
ProvisionClusterRequest provisionClusterRequest=new ProvisionClusterRequest(properties,null);
assertEquals(CLUSTER_NAME,provisionClusterRequest.getClusterName());
assertEquals(TopologyRequest.Type.PROVISION,provisionClusterRequest.getType());
assertEquals(String.format("Provision Cluster '%s'",CLUSTER_NAME),provisionClusterRequest.getDescription());
assertSame(blueprint,provisionClusterRequest.getBlueprint());
Map hostGroupInfo=provisionClusterRequest.getHostGroupInfo();
assertEquals(1,hostGroupInfo.size());
assertEquals(1,provisionClusterRequest.getTopologyValidators().size());
HostGroupInfo group2Info=hostGroupInfo.get("group2");
assertEquals("group2",group2Info.getHostGroupName());
assertTrue(group2Info.getHostNames().isEmpty());
assertEquals(5,group2Info.getRequestedHostCount());
assertNull(group2Info.getPredicate());
Configuration group2Configuration=group2Info.getConfiguration();
assertNull(group2Configuration.getParentConfiguration());
assertEquals(1,group2Configuration.getProperties().size());
Map group2TypeProperties=group2Configuration.getProperties().get("foo-type");
assertEquals(1,group2TypeProperties.size());
assertEquals("prop1Value",group2TypeProperties.get("hostGroup2Prop1"));
Map>> group2Attributes=group2Configuration.getAttributes();
assertEquals(1,group2Attributes.size());
Map> group2Type1Attributes=group2Attributes.get("foo-type");
assertEquals(1,group2Type1Attributes.size());
Map group2Type1Prop1Attributes=group2Type1Attributes.get("hostGroup2Prop10");
assertEquals(1,group2Type1Prop1Attributes.size());
assertEquals("attribute1Prop10-value",group2Type1Prop1Attributes.get("attribute1"));
Configuration clusterScopeConfiguration=provisionClusterRequest.getConfiguration();
assertSame(blueprintConfig,clusterScopeConfiguration.getParentConfiguration());
assertEquals(1,clusterScopeConfiguration.getProperties().size());
Map clusterScopedProperties=clusterScopeConfiguration.getProperties().get("someType");
assertEquals(1,clusterScopedProperties.size());
assertEquals("someValue",clusterScopedProperties.get("property1"));
Map>> clusterScopedAttributes=clusterScopeConfiguration.getAttributes();
assertEquals(1,clusterScopedAttributes.size());
Map> clusterScopedTypeAttributes=clusterScopedAttributes.get("someType");
assertEquals(1,clusterScopedTypeAttributes.size());
Map clusterScopedTypePropertyAttributes=clusterScopedTypeAttributes.get("property1");
assertEquals(1,clusterScopedTypePropertyAttributes.size());
assertEquals("someAttributePropValue",clusterScopedTypePropertyAttributes.get("attribute1"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier properties=createBlueprintRequestProperties(CLUSTER_NAME,BLUEPRINT_NAME);
properties.put("default_password","pwd");
TopologyRequest request=new ProvisionClusterRequest(properties,null);
List validators=request.getTopologyValidators();
assertEquals(1,validators.size());
TopologyValidator pwdValidator=validators.get(0);
TopologyValidator defaultPwdValidator=new RequiredPasswordValidator("pwd");
assertEquals(pwdValidator,defaultPwdValidator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier properties=createBlueprintRequestPropertiesNameOnly(CLUSTER_NAME,BLUEPRINT_NAME);
ProvisionClusterRequest provisionClusterRequest=new ProvisionClusterRequest(properties,null);
assertEquals(CLUSTER_NAME,provisionClusterRequest.getClusterName());
assertEquals(TopologyRequest.Type.PROVISION,provisionClusterRequest.getType());
assertEquals(String.format("Provision Cluster '%s'",CLUSTER_NAME),provisionClusterRequest.getDescription());
assertSame(blueprint,provisionClusterRequest.getBlueprint());
Map hostGroupInfo=provisionClusterRequest.getHostGroupInfo();
assertEquals(1,hostGroupInfo.size());
assertEquals(1,provisionClusterRequest.getTopologyValidators().size());
HostGroupInfo group1Info=hostGroupInfo.get("group1");
assertEquals("group1",group1Info.getHostGroupName());
assertEquals(1,group1Info.getHostNames().size());
assertTrue(group1Info.getHostNames().contains("host1.myDomain.com"));
assertEquals(1,group1Info.getRequestedHostCount());
assertNull(group1Info.getPredicate());
Configuration group1Configuration=group1Info.getConfiguration();
assertNull(group1Configuration.getParentConfiguration());
assertEquals(1,group1Configuration.getProperties().size());
Map group1TypeProperties=group1Configuration.getProperties().get("foo-type");
assertEquals(2,group1TypeProperties.size());
assertEquals("prop1Value",group1TypeProperties.get("hostGroup1Prop1"));
assertEquals("prop2Value",group1TypeProperties.get("hostGroup1Prop2"));
assertTrue(group1Configuration.getAttributes().isEmpty());
Configuration clusterScopeConfiguration=provisionClusterRequest.getConfiguration();
assertSame(blueprintConfig,clusterScopeConfiguration.getParentConfiguration());
assertEquals(1,clusterScopeConfiguration.getProperties().size());
Map clusterScopedProperties=clusterScopeConfiguration.getProperties().get("someType");
assertEquals(1,clusterScopedProperties.size());
assertEquals("someValue",clusterScopedProperties.get("property1"));
Map>> clusterScopedAttributes=clusterScopeConfiguration.getAttributes();
assertEquals(1,clusterScopedAttributes.size());
Map> clusterScopedTypeAttributes=clusterScopedAttributes.get("someType");
assertEquals(1,clusterScopedTypeAttributes.size());
Map clusterScopedTypePropertyAttributes=clusterScopedTypeAttributes.get("property1");
assertEquals(1,clusterScopedTypePropertyAttributes.size());
assertEquals("someAttributePropValue",clusterScopedTypePropertyAttributes.get("attribute1"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier properties=createBlueprintRequestProperties(CLUSTER_NAME,BLUEPRINT_NAME);
TopologyRequest request=new ProvisionClusterRequest(properties,null);
List validators=request.getTopologyValidators();
assertEquals(1,validators.size());
TopologyValidator pwdValidator=validators.get(0);
TopologyValidator noDefaultPwdValidator=new RequiredPasswordValidator(null);
assertEquals(pwdValidator,noDefaultPwdValidator);
}
Class: org.apache.ambari.server.controller.internal.RepositoryResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier allResponse=new HashSet();
allResponse.add(rr);
expect(managementController.getRepositories(EasyMock.>anyObject())).andReturn(allResponse).times(1);
replay(managementController);
ResourceProvider provider=new RepositoryResourceProvider(managementController);
Set propertyIds=new HashSet();
propertyIds.add(RepositoryResourceProvider.REPOSITORY_STACK_NAME_PROPERTY_ID);
propertyIds.add(RepositoryResourceProvider.REPOSITORY_STACK_VERSION_PROPERTY_ID);
propertyIds.add(RepositoryResourceProvider.REPOSITORY_REPO_NAME_PROPERTY_ID);
propertyIds.add(RepositoryResourceProvider.REPOSITORY_BASE_URL_PROPERTY_ID);
propertyIds.add(RepositoryResourceProvider.REPOSITORY_OS_TYPE_PROPERTY_ID);
propertyIds.add(RepositoryResourceProvider.REPOSITORY_REPO_ID_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(RepositoryResourceProvider.REPOSITORY_STACK_NAME_PROPERTY_ID).equals(VAL_STACK_NAME).and().property(RepositoryResourceProvider.REPOSITORY_STACK_VERSION_PROPERTY_ID).equals(VAL_STACK_VERSION).toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(allResponse.size(),resources.size());
for ( Resource resource : resources) {
Object o=resource.getPropertyValue(RepositoryResourceProvider.REPOSITORY_STACK_NAME_PROPERTY_ID);
Assert.assertEquals(VAL_STACK_NAME,o);
o=resource.getPropertyValue(RepositoryResourceProvider.REPOSITORY_STACK_VERSION_PROPERTY_ID);
Assert.assertEquals(VAL_STACK_VERSION,o);
o=resource.getPropertyValue(RepositoryResourceProvider.REPOSITORY_REPO_NAME_PROPERTY_ID);
Assert.assertEquals(o,VAL_REPO_NAME);
o=resource.getPropertyValue(RepositoryResourceProvider.REPOSITORY_BASE_URL_PROPERTY_ID);
Assert.assertEquals(o,VAL_BASE_URL);
o=resource.getPropertyValue(RepositoryResourceProvider.REPOSITORY_OS_TYPE_PROPERTY_ID);
Assert.assertEquals(o,VAL_OS);
o=resource.getPropertyValue(RepositoryResourceProvider.REPOSITORY_REPO_ID_PROPERTY_ID);
Assert.assertEquals(o,VAL_REPO_ID);
}
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.RepositoryVersionResourceProviderTest UtilityVerifier InternalCallVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.controller.internal.RequestImplTest InternalCallVerifier BooleanVerifier validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("HostRoles/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("params/run_smoke_test"));
Assert.assertTrue(validPropertyIds.contains("HostRoles/actual_configs"));
Assert.assertTrue(validPropertyIds.contains("HostRoles/desired_stack_id"));
Assert.assertTrue(validPropertyIds.contains("HostRoles/stack_id"));
Assert.assertTrue(validPropertyIds.contains("HostRoles/desired_state"));
Assert.assertTrue(validPropertyIds.contains("HostRoles/state"));
Assert.assertTrue(validPropertyIds.contains("HostRoles/component_name"));
Assert.assertTrue(validPropertyIds.contains("HostRoles/host_name"));
Assert.assertTrue(validPropertyIds.contains("HostRoles/cluster_name"));
Assert.assertTrue(validPropertyIds.contains("HostRoles/role_id"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.Cluster));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("Clusters/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("Clusters/cluster_id"));
Assert.assertTrue(validPropertyIds.contains("Clusters/cluster_name"));
Assert.assertTrue(validPropertyIds.contains("Clusters/version"));
Assert.assertTrue(validPropertyIds.contains("Clusters/state"));
Assert.assertTrue(validPropertyIds.contains("Clusters/desired_configs"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.Service));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("ServiceInfo/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("ServiceInfo/service_name"));
Assert.assertTrue(validPropertyIds.contains("ServiceInfo/cluster_name"));
Assert.assertTrue(validPropertyIds.contains("ServiceInfo/state"));
Assert.assertTrue(validPropertyIds.contains("Services/description"));
Assert.assertTrue(validPropertyIds.contains("Services/display_name"));
Assert.assertTrue(validPropertyIds.contains("Services/attributes"));
Assert.assertTrue(validPropertyIds.contains("params/run_smoke_test"));
Assert.assertTrue(validPropertyIds.contains("params/reconfigure_client"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.Host));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("Hosts/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("Hosts/cluster_name"));
Assert.assertTrue(validPropertyIds.contains("Hosts/host_name"));
Assert.assertTrue(validPropertyIds.contains("Hosts/ip"));
Assert.assertTrue(validPropertyIds.contains("Hosts/attributes"));
Assert.assertTrue(validPropertyIds.contains("Hosts/total_mem"));
Assert.assertTrue(validPropertyIds.contains("Hosts/cpu_count"));
Assert.assertTrue(validPropertyIds.contains("Hosts/ph_cpu_count"));
Assert.assertTrue(validPropertyIds.contains("Hosts/os_arch"));
Assert.assertTrue(validPropertyIds.contains("Hosts/os_type"));
Assert.assertTrue(validPropertyIds.contains("Hosts/rack_info"));
Assert.assertTrue(validPropertyIds.contains("Hosts/last_heartbeat_time"));
Assert.assertTrue(validPropertyIds.contains("Hosts/last_agent_env"));
Assert.assertTrue(validPropertyIds.contains("Hosts/last_registration_time"));
Assert.assertTrue(validPropertyIds.contains("Hosts/disk_info"));
Assert.assertTrue(validPropertyIds.contains("Hosts/host_status"));
Assert.assertTrue(validPropertyIds.contains("Hosts/host_health_report"));
Assert.assertTrue(validPropertyIds.contains("Hosts/public_host_name"));
Assert.assertTrue(validPropertyIds.contains("Hosts/host_state"));
Assert.assertTrue(validPropertyIds.contains("Hosts/desired_configs"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.Component));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("ServiceComponentInfo/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("ServiceComponentInfo/service_name"));
Assert.assertTrue(validPropertyIds.contains("ServiceComponentInfo/component_name"));
Assert.assertTrue(validPropertyIds.contains("ServiceComponentInfo/cluster_name"));
Assert.assertTrue(validPropertyIds.contains("ServiceComponentInfo/state"));
Assert.assertTrue(validPropertyIds.contains("ServiceComponents/display_name"));
Assert.assertTrue(validPropertyIds.contains("ServiceComponents/description"));
Assert.assertTrue(validPropertyIds.contains("params/run_smoke_test"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.Action));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("Action/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("Actions/action_name"));
Assert.assertTrue(validPropertyIds.contains("Actions/action_type"));
Assert.assertTrue(validPropertyIds.contains("Actions/inputs"));
Assert.assertTrue(validPropertyIds.contains("Actions/target_service"));
Assert.assertTrue(validPropertyIds.contains("Actions/target_component"));
Assert.assertTrue(validPropertyIds.contains("Actions/description"));
Assert.assertTrue(validPropertyIds.contains("Actions/target_type"));
Assert.assertTrue(validPropertyIds.contains("Actions/default_timeout"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.Request));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("Requests/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("Requests/id"));
Assert.assertTrue(validPropertyIds.contains("Requests/cluster_name"));
Assert.assertTrue(validPropertyIds.contains("Requests/request_status"));
Assert.assertTrue(validPropertyIds.contains("Requests/request_context"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.Task));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("Task/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("Tasks/id"));
Assert.assertTrue(validPropertyIds.contains("Tasks/request_id"));
Assert.assertTrue(validPropertyIds.contains("Tasks/cluster_name"));
Assert.assertTrue(validPropertyIds.contains("Tasks/stage_id"));
Assert.assertTrue(validPropertyIds.contains("Tasks/host_name"));
Assert.assertTrue(validPropertyIds.contains("Tasks/command"));
Assert.assertTrue(validPropertyIds.contains("Tasks/role"));
Assert.assertTrue(validPropertyIds.contains("Tasks/status"));
Assert.assertTrue(validPropertyIds.contains("Tasks/exit_code"));
Assert.assertTrue(validPropertyIds.contains("Tasks/stderr"));
Assert.assertTrue(validPropertyIds.contains("Tasks/stdout"));
Assert.assertTrue(validPropertyIds.contains("Tasks/start_time"));
Assert.assertTrue(validPropertyIds.contains("Tasks/attempt_cnt"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.User));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("Users/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("Users/user_name"));
Assert.assertTrue(validPropertyIds.contains("Users/password"));
Assert.assertTrue(validPropertyIds.contains("Users/old_password"));
Assert.assertTrue(validPropertyIds.contains("Users/ldap_user"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.Stack));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("Stacks/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("Stacks/stack_name"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.StackVersion));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("Versions/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("Versions/stack_name"));
Assert.assertTrue(validPropertyIds.contains("Versions/stack_version"));
Assert.assertTrue(validPropertyIds.contains("Versions/min_upgrade_version"));
request=PropertyHelper.getReadRequest(OperatingSystemResourceProvider.propertyIds);
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("OperatingSystems/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("OperatingSystems/stack_name"));
Assert.assertTrue(validPropertyIds.contains("OperatingSystems/stack_version"));
Assert.assertTrue(validPropertyIds.contains("OperatingSystems/os_type"));
request=PropertyHelper.getReadRequest(RepositoryResourceProvider.propertyIds);
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("Repositories/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("Repositories/stack_name"));
Assert.assertTrue(validPropertyIds.contains("Repositories/stack_version"));
Assert.assertTrue(validPropertyIds.contains("Repositories/os_type"));
Assert.assertTrue(validPropertyIds.contains("Repositories/base_url"));
Assert.assertTrue(validPropertyIds.contains("Repositories/repo_id"));
Assert.assertTrue(validPropertyIds.contains("Repositories/repo_name"));
Assert.assertTrue(validPropertyIds.contains("Repositories/mirrors_list"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.StackService));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("StackServices/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("StackServices/stack_name"));
Assert.assertTrue(validPropertyIds.contains("StackServices/stack_version"));
Assert.assertTrue(validPropertyIds.contains("StackServices/service_name"));
Assert.assertTrue(validPropertyIds.contains("StackServices/user_name"));
Assert.assertTrue(validPropertyIds.contains("StackServices/comments"));
Assert.assertTrue(validPropertyIds.contains("StackServices/service_version"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.StackConfiguration));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("StackConfigurations/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("StackConfigurations/stack_name"));
Assert.assertTrue(validPropertyIds.contains("StackConfigurations/stack_version"));
Assert.assertTrue(validPropertyIds.contains("StackConfigurations/service_name"));
Assert.assertTrue(validPropertyIds.contains("StackConfigurations/property_name"));
Assert.assertTrue(validPropertyIds.contains("StackConfigurations/property_description"));
Assert.assertTrue(validPropertyIds.contains("StackConfigurations/property_value"));
request=PropertyHelper.getReadRequest(PropertyHelper.getPropertyIds(Resource.Type.StackServiceComponent));
validPropertyIds=request.getPropertyIds();
Assert.assertFalse(validPropertyIds.contains("StackServiceComponents/unsupported_property_id"));
Assert.assertTrue(validPropertyIds.contains("StackServiceComponents/stack_version"));
Assert.assertTrue(validPropertyIds.contains("StackServiceComponents/stack_name"));
Assert.assertTrue(validPropertyIds.contains("StackServiceComponents/service_name"));
Assert.assertTrue(validPropertyIds.contains("StackServiceComponents/component_name"));
Assert.assertTrue(validPropertyIds.contains("StackServiceComponents/component_category"));
Assert.assertTrue(validPropertyIds.contains("StackServiceComponents/is_master"));
Assert.assertTrue(validPropertyIds.contains("StackServiceComponents/is_client"));
}
Class: org.apache.ambari.server.controller.internal.RequestOperationLevelTest UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier requestInfoProperties=new HashMap();
requestInfoProperties.put(RequestResourceProvider.COMMAND_ID,"RESTART");
requestInfoProperties.put(RequestOperationLevel.OPERATION_LEVEL_ID,host_component);
requestInfoProperties.put(RequestOperationLevel.OPERATION_CLUSTER_ID,c1);
requestInfoProperties.put(RequestOperationLevel.OPERATION_SERVICE_ID,service_id);
requestInfoProperties.put(RequestOperationLevel.OPERATION_HOSTCOMPONENT_ID,hostcomponent_id);
requestInfoProperties.put(RequestOperationLevel.OPERATION_HOST_NAME,host_id);
RequestOperationLevel opLevel=new RequestOperationLevel(requestInfoProperties);
assertEquals(opLevel.getLevel().toString(),"HostComponent");
assertEquals(opLevel.getClusterName(),c1);
assertEquals(opLevel.getServiceName(),service_id);
assertEquals(opLevel.getHostComponentName(),hostcomponent_id);
assertEquals(opLevel.getHostName(),host_id);
requestInfoProperties.put(RequestOperationLevel.OPERATION_LEVEL_ID,"wrong_value");
try {
new RequestOperationLevel(requestInfoProperties);
Assert.fail("Should throw an exception");
}
catch ( IllegalArgumentException e) {
}
requestInfoProperties.put(RequestOperationLevel.OPERATION_LEVEL_ID,host_component);
requestInfoProperties.remove(RequestOperationLevel.OPERATION_CLUSTER_ID);
try {
new RequestOperationLevel(requestInfoProperties);
Assert.fail("Should throw an exception");
}
catch ( IllegalArgumentException e) {
}
}
Class: org.apache.ambari.server.controller.internal.RequestResourceProviderTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier actionRequest=newCapture();
Capture> propertyMap=newCapture();
AmbariManagementController managementController=createMock(AmbariManagementController.class);
RequestStatusResponse response=createNiceMock(RequestStatusResponse.class);
expect(managementController.createAction(capture(actionRequest),capture(propertyMap))).andReturn(response).anyTimes();
expect(response.getMessage()).andReturn("Message").anyTimes();
replay(managementController,response);
Set> propertySet=new LinkedHashSet>();
Map properties=new LinkedHashMap();
Set> filterSet=new HashSet>();
Map filterMap=new HashMap();
filterMap.put(RequestResourceProvider.HOSTS_ID,"h1,h2");
filterSet.add(filterMap);
properties.put(RequestResourceProvider.REQUEST_RESOURCE_FILTER_ID,filterSet);
propertySet.add(properties);
Map requestInfoProperties=new HashMap();
requestInfoProperties.put(RequestResourceProvider.ACTION_ID,"check_java");
Request request=PropertyHelper.getCreateRequest(propertySet,requestInfoProperties);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
provider.createResources(request);
ExecuteActionRequest capturedRequest=actionRequest.getValue();
Assert.assertTrue(actionRequest.hasCaptured());
Assert.assertFalse("expected an action",capturedRequest.isCommand());
Assert.assertEquals("check_java",capturedRequest.getActionName());
Assert.assertEquals(null,capturedRequest.getCommandName());
Assert.assertNotNull(capturedRequest.getResourceFilters());
Assert.assertEquals(1,capturedRequest.getResourceFilters().size());
RequestResourceFilter capturedResourceFilter=capturedRequest.getResourceFilters().get(0);
Assert.assertEquals(null,capturedResourceFilter.getServiceName());
Assert.assertEquals(null,capturedResourceFilter.getComponentName());
Assert.assertNotNull(capturedResourceFilter.getHostNames());
Assert.assertEquals(2,capturedResourceFilter.getHostNames().size());
Assert.assertEquals(0,actionRequest.getValue().getParameters().size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > requestIdsCapture=newCapture();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Arrays.asList(requestMock0));
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Arrays.asList(requestMock1));
expect(hrcDAO.findAggregateCounts((Long)anyObject())).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().completed(2));
}
}
).anyTimes();
replay(managementController,actionManager,requestMock0,requestMock1,requestDAO,hrcDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_COMPLETED_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_FAILED_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_PROGRESS_PERCENT_ID);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").or().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("101").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(2,resources.size());
for ( Resource resource : resources) {
long id=(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
Assert.assertTrue(id == 100L || id == 101L);
Assert.assertEquals("COMPLETED",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
Assert.assertEquals(2,resource.getPropertyValue(RequestResourceProvider.REQUEST_TASK_CNT_ID));
Assert.assertEquals(0,resource.getPropertyValue(RequestResourceProvider.REQUEST_FAILED_TASK_CNT_ID));
Assert.assertEquals(2,resource.getPropertyValue(RequestResourceProvider.REQUEST_COMPLETED_TASK_CNT_ID));
Assert.assertEquals(100.0,resource.getPropertyValue(RequestResourceProvider.REQUEST_PROGRESS_PERCENT_ID));
}
verify(managementController,actionManager,requestMock0,requestMock1,requestDAO,hrcDAO);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > requestIdsCapture=newCapture();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster(anyObject(String.class))).andReturn(null).anyTimes();
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Collections.singletonList(requestMock));
expect(hrcDAO.findAggregateCounts((Long)anyObject())).andReturn(Collections.emptyMap()).anyTimes();
replay(managementController,actionManager,clusters,requestMock,requestDAO,hrcDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_PROGRESS_PERCENT_ID);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals(100L,(long)(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID));
Assert.assertEquals("COMPLETED",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
Assert.assertEquals(100.0,resource.getPropertyValue(RequestResourceProvider.REQUEST_PROGRESS_PERCENT_ID));
}
verify(managementController,actionManager,clusters,requestMock,requestDAO,hrcDAO);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > requestIdsCapture=newCapture();
expect(managementController.getActionManager()).andReturn(actionManager);
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Collections.singletonList(requestMock)).anyTimes();
expect(hrcDAO.findAggregateCounts((Long)anyObject())).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().inProgress(1));
}
}
).anyTimes();
replay(managementController,actionManager,requestDAO,hrcDAO,requestMock);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals(100L,(long)(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID));
Assert.assertEquals("IN_PROGRESS",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
}
verify(managementController,actionManager,requestDAO,hrcDAO);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > requestIdsCapture=newCapture();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster(anyObject(String.class))).andReturn(null).anyTimes();
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Collections.singletonList(requestMock));
expect(hrcDAO.findAggregateCounts((Long)anyObject())).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().inProgress(1));
}
}
).anyTimes();
replay(managementController,actionManager,clusters,requestMock,requestDAO,hrcDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals(100L,(long)(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID));
Assert.assertEquals("IN_PROGRESS",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
Assert.assertNull(resource.getPropertyValue(RequestResourceProvider.REQUEST_CLUSTER_NAME_PROPERTY_ID));
}
verify(managementController,actionManager,clusters,requestMock,requestDAO,hrcDAO);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > requestIdsCapture=newCapture();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster("c1")).andReturn(cluster).anyTimes();
expect(clusters.getCluster("bad-cluster")).andThrow(new AmbariException("bad cluster!")).anyTimes();
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Collections.singletonList(requestMock));
expect(hrcDAO.findAggregateCounts((Long)anyObject())).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().inProgress(1));
}
}
).anyTimes();
replay(managementController,actionManager,clusters,cluster,requestMock,requestDAO,hrcDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_CLUSTER_NAME_PROPERTY_ID).equals("c1").and().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals(100L,(long)(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID));
Assert.assertEquals("IN_PROGRESS",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
}
predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_CLUSTER_NAME_PROPERTY_ID).equals("bad-cluster").and().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").toPredicate();
try {
provider.getResources(request,predicate);
}
catch ( NoSuchParentResourceException e) {
e.printStackTrace();
}
verify(managementController,actionManager,clusters,cluster,requestMock,requestDAO,hrcDAO);
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > requestIdsCapture=new Capture>();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Arrays.asList(requestMock0));
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Arrays.asList(requestMock1));
expect(hrcDAO.findAggregateCounts(100L)).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().inProgress(1).pending(1));
}
}
).once();
expect(hrcDAO.findAggregateCounts(101L)).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().inProgress(1).queued(1));
}
}
).once();
replay(managementController,actionManager,requestMock0,requestMock1,requestDAO,hrcDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_COMPLETED_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_FAILED_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_QUEUED_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_PROGRESS_PERCENT_ID);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").or().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("101").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(2,resources.size());
for ( Resource resource : resources) {
long id=(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
Assert.assertTrue(id == 100L || id == 101L);
Assert.assertEquals("IN_PROGRESS",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
Assert.assertEquals(2,resource.getPropertyValue(RequestResourceProvider.REQUEST_TASK_CNT_ID));
Assert.assertEquals(0,resource.getPropertyValue(RequestResourceProvider.REQUEST_FAILED_TASK_CNT_ID));
if (id == 100L) {
Assert.assertEquals(0,resource.getPropertyValue(RequestResourceProvider.REQUEST_QUEUED_TASK_CNT_ID));
int progressPercent=((Double)resource.getPropertyValue(RequestResourceProvider.REQUEST_PROGRESS_PERCENT_ID)).intValue();
Assert.assertEquals(17,progressPercent);
}
else {
Assert.assertEquals(1,resource.getPropertyValue(RequestResourceProvider.REQUEST_QUEUED_TASK_CNT_ID));
int progressPercent=((Double)resource.getPropertyValue(RequestResourceProvider.REQUEST_PROGRESS_PERCENT_ID)).intValue();
Assert.assertEquals(21,progressPercent);
}
Assert.assertEquals(0,resource.getPropertyValue(RequestResourceProvider.REQUEST_COMPLETED_TASK_CNT_ID));
}
verify(managementController,actionManager,requestMock0,requestMock1,requestDAO,hrcDAO);
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > requestIdsCapture=new Capture>();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Arrays.asList(requestMock0));
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Arrays.asList(requestMock1));
expect(hrcDAO.findAggregateCounts(100L)).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().failed(1).completed(1));
}
}
).once();
expect(hrcDAO.findAggregateCounts(101L)).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().aborted(1).timedout(1));
}
}
).once();
replay(managementController,actionManager,requestMock0,requestMock1,requestDAO,hrcDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_COMPLETED_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_FAILED_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_ABORTED_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_TIMED_OUT_TASK_CNT_ID);
propertyIds.add(RequestResourceProvider.REQUEST_PROGRESS_PERCENT_ID);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").or().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("101").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(2,resources.size());
for ( Resource resource : resources) {
long id=(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
Assert.assertTrue(id == 100L || id == 101L);
Assert.assertEquals(2,resource.getPropertyValue(RequestResourceProvider.REQUEST_TASK_CNT_ID));
if (id == 100L) {
Assert.assertEquals("FAILED",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
Assert.assertEquals(1,resource.getPropertyValue(RequestResourceProvider.REQUEST_FAILED_TASK_CNT_ID));
Assert.assertEquals(0,resource.getPropertyValue(RequestResourceProvider.REQUEST_ABORTED_TASK_CNT_ID));
Assert.assertEquals(0,resource.getPropertyValue(RequestResourceProvider.REQUEST_TIMED_OUT_TASK_CNT_ID));
}
else {
Assert.assertEquals("ABORTED",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
Assert.assertEquals(0,resource.getPropertyValue(RequestResourceProvider.REQUEST_FAILED_TASK_CNT_ID));
Assert.assertEquals(1,resource.getPropertyValue(RequestResourceProvider.REQUEST_ABORTED_TASK_CNT_ID));
Assert.assertEquals(1,resource.getPropertyValue(RequestResourceProvider.REQUEST_TIMED_OUT_TASK_CNT_ID));
}
Assert.assertEquals(2,resource.getPropertyValue(RequestResourceProvider.REQUEST_COMPLETED_TASK_CNT_ID));
Assert.assertEquals(100.0,resource.getPropertyValue(RequestResourceProvider.REQUEST_PROGRESS_PERCENT_ID));
}
verify(managementController,actionManager,requestMock0,requestMock1,requestDAO,hrcDAO);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > requestIdsCapture=newCapture();
expect(managementController.getActionManager()).andReturn(actionManager);
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Collections.singletonList(requestMock)).anyTimes();
expect(hrcDAO.findAggregateCounts((Long)anyObject())).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().inProgress(1));
}
}
).anyTimes();
replay(managementController,actionManager,requestDAO,hrcDAO,requestMock);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_SOURCE_SCHEDULE);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals(100L,(long)(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID));
Assert.assertEquals("IN_PROGRESS",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
Assert.assertEquals(11L,(long)(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_SOURCE_SCHEDULE_ID));
}
verify(managementController,actionManager,requestDAO,hrcDAO);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > requestIdsCapture=newCapture();
expect(managementController.getActionManager()).andReturn(actionManager);
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Collections.singletonList(requestMock)).anyTimes();
expect(hrcDAO.findAggregateCounts((Long)anyObject())).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().inProgress(1));
}
}
).anyTimes();
replay(managementController,actionManager,requestMock,requestDAO,hrcDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID);
propertyIds.add(RequestResourceProvider.REQUEST_SOURCE_SCHEDULE);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals(100L,(long)(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID));
Assert.assertEquals("IN_PROGRESS",resource.getPropertyValue(RequestResourceProvider.REQUEST_STATUS_PROPERTY_ID));
Assert.assertEquals(null,resource.getPropertyValue(RequestResourceProvider.REQUEST_SOURCE_SCHEDULE));
}
verify(managementController,actionManager,requestMock,requestDAO,hrcDAO);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > requestIdsCapture=newCapture();
expect(managementController.getActionManager()).andReturn(actionManager).anyTimes();
expect(requestDAO.findByPks(capture(requestIdsCapture),eq(true))).andReturn(Arrays.asList(requestMock,requestMock1)).anyTimes();
expect(hrcDAO.findAggregateCounts((Long)anyObject())).andReturn(new HashMap(){
{
put(1L,HostRoleCommandStatusSummaryDTO.create().inProgress(1));
}
}
).anyTimes();
replay(managementController,actionManager,requestMock,requestMock1,requestDAO,hrcDAO);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("100").or().property(RequestResourceProvider.REQUEST_ID_PROPERTY_ID).equals("101").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(2,resources.size());
for ( Resource resource : resources) {
long id=(Long)resource.getPropertyValue(RequestResourceProvider.REQUEST_ID_PROPERTY_ID);
Assert.assertTrue(id == 100L || id == 101L);
}
verify(managementController,actionManager,requestMock,requestMock1,requestDAO,hrcDAO);
}
Class: org.apache.ambari.server.controller.internal.RequestScheduleResourceProviderTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier clusterCapture=new Capture();
Capture batchCapture=new Capture();
Capture scheduleCapture=new Capture();
expect(executionFactory.createNew(capture(clusterCapture),capture(batchCapture),capture(scheduleCapture))).andReturn(requestExecution);
replay(managementController,clusters,cluster,executionFactory,requestExecution,response,executionScheduleManager);
RequestScheduleResourceProvider resourceProvider=getResourceProvider(managementController);
Set> propertySet=new LinkedHashSet>();
Map properties=new LinkedHashMap();
properties.put(RequestScheduleResourceProvider.REQUEST_SCHEDULE_CLUSTER_NAME_PROPERTY_ID,"Cluster100");
properties.put(RequestScheduleResourceProvider.REQUEST_SCHEDULE_DESC_PROPERTY_ID,"some description");
properties.put(RequestScheduleResourceProvider.SCHEDULE_DAY_OF_WEEK_PROPERTY_ID,"MON");
properties.put(RequestScheduleResourceProvider.SCHEDULE_MINUTES_PROPERTY_ID,"2");
properties.put(RequestScheduleResourceProvider.SCHEDULE_END_TIME_PROPERTY_ID,"2013-11-18T14:29:29-08:00");
properties.put(RequestScheduleResourceProvider.SCHEDULE_DAYS_OF_MONTH_PROPERTY_ID,"*");
HashSet> batch=new HashSet>();
Map batchSettings=new HashMap();
batchSettings.put(RequestScheduleResourceProvider.REQUEST_SCHEDULE_BATCH_SEPARATION_PROPERTY_ID,"15");
Map batchRequests=new HashMap();
HashSet> requestSet=new HashSet>();
Map request1=new HashMap();
Map request2=new HashMap();
request1.put(RequestScheduleResourceProvider.BATCH_REQUEST_TYPE_PROPERTY_ID,BatchRequest.Type.PUT.name());
request1.put(RequestScheduleResourceProvider.BATCH_REQUEST_ORDER_ID_PROPERTY_ID,"20");
request1.put(RequestScheduleResourceProvider.BATCH_REQUEST_URI_PROPERTY_ID,"SomeUpdateUri");
request1.put(RequestScheduleResourceProvider.BATCH_REQUEST_BODY_PROPERTY_ID,"data1");
request2.put(RequestScheduleResourceProvider.BATCH_REQUEST_TYPE_PROPERTY_ID,BatchRequest.Type.DELETE.name());
request2.put(RequestScheduleResourceProvider.BATCH_REQUEST_ORDER_ID_PROPERTY_ID,"22");
request2.put(RequestScheduleResourceProvider.BATCH_REQUEST_URI_PROPERTY_ID,"SomeDeleteUri");
requestSet.add(request1);
requestSet.add(request2);
batchRequests.put(RequestScheduleResourceProvider.REQUEST_SCHEDULE_BATCH_REQUESTS_PROPERTY_ID,requestSet);
batch.add(batchSettings);
batch.add(batchRequests);
properties.put(RequestScheduleResourceProvider.REQUEST_SCHEDULE_BATCH_PROPERTY_ID,batch);
propertySet.add(properties);
Request request=PropertyHelper.getCreateRequest(propertySet,null);
resourceProvider.createResources(request);
verify(managementController,clusters,cluster,executionFactory,requestExecution,response,executionScheduleManager);
List testRequests=batchCapture.getValue().getBatchRequests();
Assert.assertNotNull(testRequests);
BatchRequest deleteReq=null;
BatchRequest putReq=null;
for ( BatchRequest testBatchRequest : testRequests) {
if (testBatchRequest.getType().equals(BatchRequest.Type.DELETE.name())) {
deleteReq=testBatchRequest;
}
else {
putReq=testBatchRequest;
}
}
Assert.assertNotNull(deleteReq);
Assert.assertNotNull(putReq);
Assert.assertEquals("data1",putReq.getBody());
Assert.assertNull(deleteReq.getBody());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier requestExecutionMap=new HashMap();
requestExecutionMap.put(1L,requestExecution);
expect(managementController.getAuthName()).andReturn("admin").anyTimes();
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getExecutionScheduleManager()).andReturn(executionScheduleManager).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(cluster.getAllRequestExecutions()).andReturn(requestExecutionMap);
replay(managementController,clusters,cluster,executionScheduleManager,requestExecution);
RequestScheduleResourceProvider resourceProvider=getResourceProvider(managementController);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
((ObservableResourceProvider)resourceProvider).addObserver(observer);
Predicate predicate=new PredicateBuilder().property(RequestScheduleResourceProvider.REQUEST_SCHEDULE_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(RequestScheduleResourceProvider.REQUEST_SCHEDULE_ID_PROPERTY_ID).equals(1L).toPredicate();
resourceProvider.deleteResources(predicate);
ResourceProviderEvent lastEvent=observer.getLastEvent();
Assert.assertNotNull(lastEvent);
Assert.assertEquals(Resource.Type.RequestSchedule,lastEvent.getResourceType());
Assert.assertEquals(ResourceProviderEvent.Type.Delete,lastEvent.getType());
Assert.assertEquals(predicate,lastEvent.getPredicate());
Assert.assertNull(lastEvent.getRequest());
verify(managementController,clusters,cluster,executionScheduleManager,requestExecution);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier >(){
@Override public Map answer() throws Throwable {
Map requestExecutionMap=new HashMap();
requestExecutionMap.put(requestExecution.getId(),requestExecution);
return requestExecutionMap;
}
}
);
replay(managementController,clusters,cluster,requestExecution,response,requestScheduleResponse);
RequestScheduleResourceProvider resourceProvider=getResourceProvider(managementController);
Map properties=new LinkedHashMap();
properties.put(RequestScheduleResourceProvider.REQUEST_SCHEDULE_CLUSTER_NAME_PROPERTY_ID,"Cluster100");
properties.put(RequestScheduleResourceProvider.REQUEST_SCHEDULE_DESC_PROPERTY_ID,"some description");
Set propertyIds=new HashSet();
propertyIds.add(RequestScheduleResourceProvider.REQUEST_SCHEDULE_CLUSTER_NAME_PROPERTY_ID);
propertyIds.add(RequestScheduleResourceProvider.REQUEST_SCHEDULE_ID_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Predicate predicate=new PredicateBuilder().property(RequestScheduleResourceProvider.REQUEST_SCHEDULE_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(RequestScheduleResourceProvider.REQUEST_SCHEDULE_ID_PROPERTY_ID).equals(25L).toPredicate();
Set resources=resourceProvider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Assert.assertEquals(25L,resources.iterator().next().getPropertyValue(RequestScheduleResourceProvider.REQUEST_SCHEDULE_ID_PROPERTY_ID));
predicate=new PredicateBuilder().property(RequestScheduleResourceProvider.REQUEST_SCHEDULE_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
resources=resourceProvider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Assert.assertEquals(25L,resources.iterator().next().getPropertyValue(RequestScheduleResourceProvider.REQUEST_SCHEDULE_ID_PROPERTY_ID));
verify(managementController,clusters,cluster,requestExecution,response,requestScheduleResponse);
}
Class: org.apache.ambari.server.controller.internal.RequestStageContainerTest APIUtilityVerifier InternalCallVerifier EqualityVerifier stages=new ArrayList();
RoleCommand roleCommand=RoleCommand.INSTALL;
HostRoleStatus status=HostRoleStatus.IN_PROGRESS;
stages.add(stage1);
stages.add(stage2);
List hostRoleCommands=new ArrayList();
hostRoleCommands.add(command1);
expect(actionManager.getRequestTasks(100)).andReturn(hostRoleCommands);
expect(actionManager.getRequestContext(100)).andReturn("test");
expect(command1.getTaskId()).andReturn(1L);
expect(command1.getRoleCommand()).andReturn(roleCommand);
expect(command1.getRole()).andReturn(role);
expect(command1.getStatus()).andReturn(status);
replay(actionManager,stage1,stage2,command1,role);
RequestStageContainer requestStages=new RequestStageContainer(100L,stages,null,actionManager);
RequestStatusResponse response=requestStages.getRequestStatusResponse();
assertEquals(100,response.getRequestId());
List tasks=response.getTasks();
assertEquals(1,tasks.size());
ShortTaskStatus task=tasks.get(0);
assertEquals(1,task.getTaskId());
assertEquals(roleCommand.toString(),task.getCommand());
assertEquals(status.toString(),task.getStatus());
assertEquals("test",response.getRequestContext());
verify(actionManager,stage1,stage2,command1,role);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier listStages=new ArrayList();
listStages.add(stage2);
listStages.add(stage3);
requestStages.addStages(listStages);
assertEquals(3,requestStages.getStages().size());
listStages=requestStages.getStages();
assertEquals(stage,listStages.get(0));
assertEquals(stage2,listStages.get(1));
assertEquals(stage3,listStages.get(2));
}
Class: org.apache.ambari.server.controller.internal.RequestStatusImplTest InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier associatedResources=Collections.singleton(associatedResource);
status=new RequestStatusImpl(null,associatedResources);
Assert.assertEquals(associatedResources,status.getAssociatedResources());
}
Class: org.apache.ambari.server.controller.internal.ResourceImplTest InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > map=resource.getPropertiesMap();
Assert.assertEquals(4,map.keySet().size());
Assert.assertTrue(map.containsKey(""));
Assert.assertTrue(map.containsKey("c1"));
Assert.assertTrue(map.containsKey("c1/c2"));
Assert.assertTrue(map.containsKey("c1/c2/c3"));
String lastCategory=null;
for ( Map.Entry> entry : map.entrySet()) {
String category=entry.getKey();
if (lastCategory != null) {
Assert.assertTrue(category.compareTo(lastCategory) > 0);
}
lastCategory=category;
String lastProperty=null;
for ( String property : entry.getValue().keySet()) {
if (lastProperty != null) {
Assert.assertTrue(property.compareTo(lastProperty) > 0);
}
lastProperty=property;
}
}
}
Class: org.apache.ambari.server.controller.internal.RoleAuthorizationResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier authorizationEntities=new ArrayList();
authorizationEntities.add(roleAuthorizationEntity1);
authorizationEntities.add(roleAuthorizationEntity2);
PermissionEntity permissionEntry=createStrictMock(PermissionEntity.class);
expect(permissionEntry.getAuthorizations()).andReturn(authorizationEntities).once();
PermissionDAO permissionDAO=injector.getInstance(PermissionDAO.class);
expect(permissionDAO.findById(1)).andReturn(permissionEntry).once();
replayAll();
AmbariManagementController managementController=injector.getInstance(AmbariManagementController.class);
RoleAuthorizationResourceProvider provider=new RoleAuthorizationResourceProvider(managementController);
Predicate predicate=new PredicateBuilder().begin().property(RoleAuthorizationResourceProvider.AUTHORIZATION_ID_PROPERTY_ID).equals("TEST.DO_SOMETHING").and().property(RoleAuthorizationResourceProvider.PERMISSION_ID_PROPERTY_ID).equals("1").end().toPredicate();
Set resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("TEST.DO_SOMETHING",resource.getPropertyValue(RoleAuthorizationResourceProvider.AUTHORIZATION_ID_PROPERTY_ID));
Assert.assertEquals("Do Something",resource.getPropertyValue(RoleAuthorizationResourceProvider.AUTHORIZATION_NAME_PROPERTY_ID));
Assert.assertEquals(1,resource.getPropertyValue(RoleAuthorizationResourceProvider.PERMISSION_ID_PROPERTY_ID));
verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier authorizationEntities=new ArrayList();
authorizationEntities.add(roleAuthorizationEntity);
PermissionEntity permissionEntry=createStrictMock(PermissionEntity.class);
expect(permissionEntry.getAuthorizations()).andReturn(authorizationEntities).once();
PermissionDAO permissionDAO=injector.getInstance(PermissionDAO.class);
expect(permissionDAO.findById(1)).andReturn(permissionEntry).once();
replayAll();
AmbariManagementController managementController=injector.getInstance(AmbariManagementController.class);
RoleAuthorizationResourceProvider provider=new RoleAuthorizationResourceProvider(managementController);
Predicate predicate=new PredicateBuilder().property(RoleAuthorizationResourceProvider.PERMISSION_ID_PROPERTY_ID).equals("1").toPredicate();
Set resources=provider.getResources(PropertyHelper.getReadRequest(),predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("TEST.DO_SOMETHING",resource.getPropertyValue(RoleAuthorizationResourceProvider.AUTHORIZATION_ID_PROPERTY_ID));
Assert.assertEquals("Do Something",resource.getPropertyValue(RoleAuthorizationResourceProvider.AUTHORIZATION_NAME_PROPERTY_ID));
Assert.assertEquals(1,resource.getPropertyValue(RoleAuthorizationResourceProvider.PERMISSION_ID_PROPERTY_ID));
verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier authorizationEntities=new ArrayList();
authorizationEntities.add(roleAuthorizationEntity);
RoleAuthorizationDAO roleAuthorizationDAO=injector.getInstance(RoleAuthorizationDAO.class);
expect(roleAuthorizationDAO.findAll()).andReturn(authorizationEntities);
replayAll();
AmbariManagementController managementController=injector.getInstance(AmbariManagementController.class);
RoleAuthorizationResourceProvider provider=new RoleAuthorizationResourceProvider(managementController);
injector.injectMembers(provider);
Set resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("TEST.DO_SOMETHING",resource.getPropertyValue(RoleAuthorizationResourceProvider.AUTHORIZATION_ID_PROPERTY_ID));
Assert.assertEquals("Do Something",resource.getPropertyValue(RoleAuthorizationResourceProvider.AUTHORIZATION_NAME_PROPERTY_ID));
Assert.assertNull(resource.getPropertyValue(RoleAuthorizationResourceProvider.PERMISSION_ID_PROPERTY_ID));
verifyAll();
}
Class: org.apache.ambari.server.controller.internal.RootServiceComponentResourceProviderTest APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier allResponse=new HashSet();
allResponse.add(new RootServiceComponentResponse("component1","1.1.1",Collections.emptyMap()));
allResponse.add(new RootServiceComponentResponse("component2","1.1.1",Collections.emptyMap()));
allResponse.add(new RootServiceComponentResponse("component3","1.1.1",Collections.emptyMap()));
allResponse.add(new RootServiceComponentResponse(RootServiceResponseFactory.Components.AMBARI_SERVER.name(),"1.1.1",Collections.emptyMap()));
Set nameResponse=new HashSet();
nameResponse.add(new RootServiceComponentResponse("component4","1.1.1",Collections.emptyMap()));
expect(managementController.getRootServiceComponents(EasyMock.>anyObject())).andReturn(allResponse).once();
expect(managementController.getRootServiceComponents(EasyMock.>anyObject())).andReturn(nameResponse).once();
replay(managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RootServiceComponentResourceProvider.SERVICE_NAME_PROPERTY_ID);
propertyIds.add(RootServiceComponentResourceProvider.COMPONENT_NAME_PROPERTY_ID);
propertyIds.add(RootServiceComponentResourceProvider.PROPERTIES_PROPERTY_ID);
propertyIds.add(RootServiceComponentResourceProvider.COMPONENT_VERSION_PROPERTY_ID);
propertyIds.add(RootServiceComponentResourceProvider.PROPERTIES_SERVER_CLOCK);
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,null);
Assert.assertEquals(allResponse.size(),resources.size());
for ( Resource resource : resources) {
String componentName=(String)resource.getPropertyValue(RootServiceComponentResourceProvider.COMPONENT_NAME_PROPERTY_ID);
String componentVersion=(String)resource.getPropertyValue(RootServiceComponentResourceProvider.COMPONENT_VERSION_PROPERTY_ID);
Long server_clock=(Long)resource.getPropertyValue(RootServiceComponentResourceProvider.PROPERTIES_SERVER_CLOCK);
if (componentName.equals(RootServiceResponseFactory.Components.AMBARI_SERVER.name())) {
Assert.assertNotNull(server_clock);
}
else {
Assert.assertNull(server_clock);
}
Assert.assertTrue(allResponse.contains(new RootServiceComponentResponse(componentName,componentVersion,Collections.emptyMap())));
}
Predicate predicate=new PredicateBuilder().property(RootServiceComponentResourceProvider.COMPONENT_NAME_PROPERTY_ID).equals("component4").toPredicate();
resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Assert.assertEquals("component4",resources.iterator().next().getPropertyValue(RootServiceComponentResourceProvider.COMPONENT_NAME_PROPERTY_ID));
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.RootServiceResourceProviderTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier allResponse=new HashSet();
allResponse.add(new RootServiceResponse("service1"));
allResponse.add(new RootServiceResponse("service2"));
allResponse.add(new RootServiceResponse("service3"));
Set nameResponse=new HashSet();
nameResponse.add(new RootServiceResponse("service4"));
expect(managementController.getRootServices(EasyMock.>anyObject())).andReturn(allResponse).once();
expect(managementController.getRootServices(EasyMock.>anyObject())).andReturn(nameResponse).once();
replay(managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(RootServiceResourceProvider.SERVICE_NAME_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,null);
Assert.assertEquals(allResponse.size(),resources.size());
for ( Resource resource : resources) {
String serviceName=(String)resource.getPropertyValue(RootServiceResourceProvider.SERVICE_NAME_PROPERTY_ID);
Assert.assertTrue(allResponse.contains(new RootServiceResponse(serviceName)));
}
Predicate predicate=new PredicateBuilder().property(RootServiceResourceProvider.SERVICE_NAME_PROPERTY_ID).equals("service4").toPredicate();
resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Assert.assertEquals("service4",resources.iterator().next().getPropertyValue(RootServiceResourceProvider.SERVICE_NAME_PROPERTY_ID));
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.ScaleClusterRequestTest APIUtilityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier hostGroupInfo=scaleClusterRequest.getHostGroupInfo();
assertEquals(1,hostGroupInfo.size());
assertEquals(0,scaleClusterRequest.getTopologyValidators().size());
HostGroupInfo group2Info=hostGroupInfo.get(GROUP2_NAME);
assertEquals(GROUP2_NAME,group2Info.getHostGroupName());
assertEquals(0,group2Info.getHostNames().size());
assertEquals(1,group2Info.getRequestedHostCount());
assertNull(group2Info.getPredicate());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier hostGroupInfo=scaleClusterRequest.getHostGroupInfo();
assertEquals(1,hostGroupInfo.size());
assertEquals(0,scaleClusterRequest.getTopologyValidators().size());
HostGroupInfo group2Info=hostGroupInfo.get(GROUP3_NAME);
assertEquals(GROUP3_NAME,group2Info.getHostGroupName());
assertEquals(0,group2Info.getHostNames().size());
assertEquals(2,group2Info.getRequestedHostCount());
assertNull(group2Info.getPredicate());
}
APIUtilityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier HybridVerifier hostGroupInfo=scaleClusterRequest.getHostGroupInfo();
assertEquals(1,hostGroupInfo.size());
assertEquals(0,scaleClusterRequest.getTopologyValidators().size());
HostGroupInfo group3Info=hostGroupInfo.get(GROUP3_NAME);
assertEquals(GROUP3_NAME,group3Info.getHostGroupName());
assertEquals(0,group3Info.getHostNames().size());
assertEquals(1,group3Info.getRequestedHostCount());
assertEquals(PREDICATE,group3Info.getPredicateString());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier > propertySet=new HashSet>();
propertySet.add(createScaleClusterPropertiesGroup1_HostName(CLUSTER_NAME,BLUEPRINT_NAME));
propertySet.add(createScaleClusterPropertiesGroup1_HostName2(CLUSTER_NAME,BLUEPRINT_NAME));
ScaleClusterRequest scaleClusterRequest=new ScaleClusterRequest(propertySet);
assertEquals(TopologyRequest.Type.SCALE,scaleClusterRequest.getType());
assertEquals(String.format("Scale Cluster '%s' (+%s hosts)",CLUSTER_NAME,"2"),scaleClusterRequest.getDescription());
assertEquals(CLUSTER_NAME,scaleClusterRequest.getClusterName());
assertSame(blueprint,scaleClusterRequest.getBlueprint());
Map hostGroupInfo=scaleClusterRequest.getHostGroupInfo();
assertEquals(1,hostGroupInfo.size());
assertEquals(0,scaleClusterRequest.getTopologyValidators().size());
HostGroupInfo group1Info=hostGroupInfo.get(GROUP1_NAME);
assertEquals(GROUP1_NAME,group1Info.getHostGroupName());
assertEquals(2,group1Info.getHostNames().size());
assertTrue(group1Info.getHostNames().contains(HOST1_NAME));
assertTrue(group1Info.getHostNames().contains(HOST2_NAME));
assertEquals(2,group1Info.getRequestedHostCount());
assertNull(group1Info.getPredicate());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier hostGroupInfo=scaleClusterRequest.getHostGroupInfo();
assertEquals(1,hostGroupInfo.size());
assertEquals(0,scaleClusterRequest.getTopologyValidators().size());
HostGroupInfo group1Info=hostGroupInfo.get(GROUP1_NAME);
assertEquals(GROUP1_NAME,group1Info.getHostGroupName());
assertEquals(1,group1Info.getHostNames().size());
assertTrue(group1Info.getHostNames().contains(HOST1_NAME));
assertEquals(1,group1Info.getRequestedHostCount());
assertNull(group1Info.getPredicate());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier > propertySet=new HashSet>();
propertySet.add(createScaleClusterPropertiesGroup1_HostCountAndPredicate(CLUSTER_NAME,BLUEPRINT_NAME));
propertySet.add(createScaleClusterPropertiesGroup1_HostCount(CLUSTER_NAME,BLUEPRINT_NAME));
propertySet.add(createScaleClusterPropertiesGroup1_HostName(CLUSTER_NAME,BLUEPRINT_NAME));
ScaleClusterRequest scaleClusterRequest=new ScaleClusterRequest(propertySet);
assertEquals(TopologyRequest.Type.SCALE,scaleClusterRequest.getType());
assertEquals(String.format("Scale Cluster '%s' (+%s hosts)",CLUSTER_NAME,"3"),scaleClusterRequest.getDescription());
assertEquals(CLUSTER_NAME,scaleClusterRequest.getClusterName());
assertSame(blueprint,scaleClusterRequest.getBlueprint());
Map hostGroupInfo=scaleClusterRequest.getHostGroupInfo();
assertEquals(3,hostGroupInfo.size());
assertEquals(0,scaleClusterRequest.getTopologyValidators().size());
HostGroupInfo group1Info=hostGroupInfo.get(GROUP1_NAME);
assertEquals(GROUP1_NAME,group1Info.getHostGroupName());
assertEquals(1,group1Info.getHostNames().size());
assertTrue(group1Info.getHostNames().contains(HOST1_NAME));
assertEquals(1,group1Info.getRequestedHostCount());
assertNull(group1Info.getPredicate());
HostGroupInfo group2Info=hostGroupInfo.get(GROUP2_NAME);
assertEquals(GROUP2_NAME,group2Info.getHostGroupName());
assertEquals(0,group2Info.getHostNames().size());
assertEquals(1,group2Info.getRequestedHostCount());
assertNull(group2Info.getPredicate());
HostGroupInfo group3Info=hostGroupInfo.get(GROUP3_NAME);
assertEquals(GROUP3_NAME,group3Info.getHostGroupName());
assertEquals(0,group3Info.getHostNames().size());
assertEquals(1,group3Info.getRequestedHostCount());
assertEquals(PREDICATE,group3Info.getPredicateString());
}
Class: org.apache.ambari.server.controller.internal.SchemaImplTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.internal.ServiceResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier ());
expect(service.getCluster()).andReturn(cluster);
cluster.deleteService(serviceName);
replay(managementController,clusters,cluster,service);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=getServiceProvider(managementController);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
((ObservableResourceProvider)provider).addObserver(observer);
Predicate predicate=new PredicateBuilder().property(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals(serviceName).toPredicate();
provider.deleteResources(predicate);
ResourceProviderEvent lastEvent=observer.getLastEvent();
Assert.assertNotNull(lastEvent);
Assert.assertEquals(Resource.Type.Service,lastEvent.getResourceType());
Assert.assertEquals(ResourceProviderEvent.Type.Delete,lastEvent.getType());
Assert.assertEquals(predicate,lastEvent.getPredicate());
Assert.assertNull(lastEvent.getRequest());
verify(managementController,clusters,cluster,service);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier allResponseMap=new HashMap();
allResponseMap.put("KERBEROS",service0);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getServiceFactory()).andReturn(serviceFactory).anyTimes();
expect(managementController.getHostComponents(EasyMock.>anyObject())).andReturn(Collections.emptySet()).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(cluster.getServices()).andReturn(allResponseMap).anyTimes();
expect(cluster.getService("KERBEROS")).andReturn(service0);
expect(service0.convertToResponse()).andReturn(serviceResponse0).anyTimes();
expect(service0.getName()).andReturn("Service100").anyTimes();
expect(serviceResponse0.getClusterName()).andReturn("Cluster100").anyTimes();
expect(serviceResponse0.getServiceName()).andReturn("KERBEROS").anyTimes();
kerberosHeper.validateKDCCredentials(cluster);
expectLastCall().andThrow(new KerberosAdminAuthenticationException("Invalid KDC administrator credentials."));
replay(managementController,clusters,cluster,service0,serviceResponse0,ambariMetaInfo,stackId,serviceFactory,kerberosHeper);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=getServiceProvider(managementController);
Class c=provider.getClass();
Field f=c.getDeclaredField("kerberosHelper");
f.setAccessible(true);
f.set(provider,kerberosHeper);
Predicate predicate=new PredicateBuilder().property(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("KERBEROS").toPredicate();
Request request=PropertyHelper.getReadRequest("ServiceInfo","Services");
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("Cluster100",resource.getPropertyValue(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID));
Assert.assertEquals("KERBEROS",resource.getPropertyValue(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID));
Assert.assertEquals("INVALID_CREDENTIALS",resource.getPropertyValue("Services/attributes/kdc_validation_result"));
Assert.assertEquals("Invalid KDC administrator credentials.",resource.getPropertyValue("Services/attributes/kdc_validation_failure_details"));
}
verify(managementController,clusters,cluster,service0,serviceResponse0,ambariMetaInfo,stackId,serviceFactory,kerberosHeper);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier allResponseMap=new HashMap();
allResponseMap.put("KERBEROS",service0);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getServiceFactory()).andReturn(serviceFactory).anyTimes();
expect(managementController.getHostComponents(EasyMock.>anyObject())).andReturn(Collections.emptySet()).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(cluster.getServices()).andReturn(allResponseMap).anyTimes();
expect(cluster.getService("KERBEROS")).andReturn(service0);
expect(service0.convertToResponse()).andReturn(serviceResponse0).anyTimes();
expect(service0.getName()).andReturn("Service100").anyTimes();
expect(serviceResponse0.getClusterName()).andReturn("Cluster100").anyTimes();
expect(serviceResponse0.getServiceName()).andReturn("KERBEROS").anyTimes();
kerberosHeper.validateKDCCredentials(cluster);
replay(managementController,clusters,cluster,service0,serviceResponse0,ambariMetaInfo,stackId,serviceFactory,kerberosHeper);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=getServiceProvider(managementController);
Class c=provider.getClass();
Field f=c.getDeclaredField("kerberosHelper");
f.setAccessible(true);
f.set(provider,kerberosHeper);
Predicate predicate=new PredicateBuilder().property(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("KERBEROS").toPredicate();
Request request=PropertyHelper.getReadRequest("ServiceInfo","Services");
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("Cluster100",resource.getPropertyValue(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID));
Assert.assertEquals("KERBEROS",resource.getPropertyValue(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID));
Assert.assertEquals("OK",resource.getPropertyValue("Services/attributes/kdc_validation_result"));
Assert.assertEquals("",resource.getPropertyValue("Services/attributes/kdc_validation_failure_details"));
}
verify(managementController,clusters,cluster,service0,serviceResponse0,ambariMetaInfo,stackId,serviceFactory,kerberosHeper);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier allResponseMap=new HashMap();
allResponseMap.put("KERBEROS",service0);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getServiceFactory()).andReturn(serviceFactory).anyTimes();
expect(managementController.getHostComponents(EasyMock.>anyObject())).andReturn(Collections.emptySet()).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(cluster.getServices()).andReturn(allResponseMap).anyTimes();
expect(cluster.getService("KERBEROS")).andReturn(service0);
expect(service0.convertToResponse()).andReturn(serviceResponse0).anyTimes();
expect(service0.getName()).andReturn("Service100").anyTimes();
expect(serviceResponse0.getClusterName()).andReturn("Cluster100").anyTimes();
expect(serviceResponse0.getServiceName()).andReturn("KERBEROS").anyTimes();
replay(managementController,clusters,cluster,service0,serviceResponse0,ambariMetaInfo,stackId,serviceFactory,kerberosHelper);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=getServiceProvider(managementController);
Class c=provider.getClass();
Field f=c.getDeclaredField("kerberosHelper");
f.setAccessible(true);
f.set(provider,kerberosHelper);
Predicate predicate=new PredicateBuilder().property(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("KERBEROS").toPredicate();
Request request=PropertyHelper.getReadRequest("ServiceInfo");
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("Cluster100",resource.getPropertyValue(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID));
Assert.assertEquals("KERBEROS",resource.getPropertyValue(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID));
}
verify(managementController,clusters,cluster,service0,serviceResponse0,ambariMetaInfo,stackId,serviceFactory,kerberosHelper);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyIds=new HashSet();
propertyIds.add("foo");
propertyIds.add("cat1/foo");
propertyIds.add("cat2/bar");
propertyIds.add("cat2/baz");
propertyIds.add("cat3/sub1/bam");
propertyIds.add("cat4/sub2/sub3/bat");
propertyIds.add("cat5/subcat5/map");
Map keyPropertyIds=new HashMap();
AmbariManagementController managementController=createMock(AmbariManagementController.class);
MaintenanceStateHelper maintenanceStateHelperMock=createNiceMock(MaintenanceStateHelper.class);
AbstractResourceProvider provider=new ServiceResourceProvider(propertyIds,keyPropertyIds,managementController,maintenanceStateHelperMock);
Set unsupported=provider.checkPropertyIds(Collections.singleton("foo"));
Assert.assertTrue(unsupported.isEmpty());
Assert.assertTrue(provider.checkPropertyIds(Collections.singleton("cat5/subcat5/map/key")).isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("bar"));
Assert.assertEquals(1,unsupported.size());
Assert.assertTrue(unsupported.contains("bar"));
unsupported=provider.checkPropertyIds(Collections.singleton("cat1/foo"));
Assert.assertTrue(unsupported.isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("cat1"));
Assert.assertTrue(unsupported.isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("config"));
Assert.assertTrue(unsupported.isEmpty());
unsupported=provider.checkPropertyIds(Collections.singleton("config/unknown_property"));
Assert.assertTrue(unsupported.isEmpty());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier allResponseMap=new HashMap();
allResponseMap.put("KERBEROS",service0);
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(managementController.getAmbariMetaInfo()).andReturn(ambariMetaInfo).anyTimes();
expect(managementController.getServiceFactory()).andReturn(serviceFactory).anyTimes();
expect(managementController.getHostComponents((Set)anyObject())).andReturn(Collections.emptySet()).anyTimes();
expect(clusters.getCluster("Cluster100")).andReturn(cluster).anyTimes();
expect(cluster.getServices()).andReturn(allResponseMap).anyTimes();
expect(cluster.getService("KERBEROS")).andReturn(service0);
expect(service0.convertToResponse()).andReturn(serviceResponse0).anyTimes();
expect(service0.getName()).andReturn("Service100").anyTimes();
expect(serviceResponse0.getClusterName()).andReturn("Cluster100").anyTimes();
expect(serviceResponse0.getServiceName()).andReturn("KERBEROS").anyTimes();
kerberosHeper.validateKDCCredentials(cluster);
expectLastCall().andThrow(new KerberosMissingAdminCredentialsException("Missing KDC administrator credentials."));
replay(managementController,clusters,cluster,service0,serviceResponse0,ambariMetaInfo,stackId,serviceFactory,kerberosHeper);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=getServiceProvider(managementController);
Class c=provider.getClass();
Field f=c.getDeclaredField("kerberosHelper");
f.setAccessible(true);
f.set(provider,kerberosHeper);
Predicate predicate=new PredicateBuilder().property(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").and().property(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals("KERBEROS").toPredicate();
Request request=PropertyHelper.getReadRequest("ServiceInfo","Services");
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
Assert.assertEquals("Cluster100",resource.getPropertyValue(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID));
Assert.assertEquals("KERBEROS",resource.getPropertyValue(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID));
Assert.assertEquals("MISSING_CREDENTIALS",resource.getPropertyValue("Services/attributes/kdc_validation_result"));
Assert.assertEquals("Missing KDC administrator credentials.",resource.getPropertyValue("Services/attributes/kdc_validation_failure_details"));
}
verify(managementController,clusters,cluster,service0,serviceResponse0,ambariMetaInfo,stackId,serviceFactory,kerberosHeper);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier scMap=new HashMap();
scMap.put(component1.Name,component1.Component);
scMap.put(component2.Name,component2.Component);
scMap.put(component3.Name,component3.Component);
String clusterName="Cluster100";
String serviceName="Service100";
expect(managementController.getClusters()).andReturn(clusters).anyTimes();
expect(clusters.getCluster(clusterName)).andReturn(cluster).anyTimes();
expect(cluster.getService(serviceName)).andReturn(service).anyTimes();
expect(service.getDesiredState()).andReturn(State.STARTED).anyTimes();
expect(service.getName()).andReturn(serviceName).anyTimes();
expect(service.getServiceComponents()).andReturn(scMap).anyTimes();
expect(component1.Component.getDesiredState()).andReturn(component1.DesiredState).anyTimes();
expect(component2.Component.getDesiredState()).andReturn(component2.DesiredState).anyTimes();
expect(component3.Component.getDesiredState()).andReturn(component3.DesiredState).anyTimes();
expect(component1.Component.canBeRemoved()).andReturn(component1.DesiredState.isRemovableState()).anyTimes();
expect(component2.Component.canBeRemoved()).andReturn(component2.DesiredState.isRemovableState()).anyTimes();
expect(component3.Component.canBeRemoved()).andReturn(component3.DesiredState.isRemovableState()).anyTimes();
expect(service.getCluster()).andReturn(cluster);
cluster.deleteService(serviceName);
replay(managementController,clusters,cluster,service,component1.Component,component2.Component,component3.Component);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
ResourceProvider provider=getServiceProvider(managementController);
AbstractResourceProviderTest.TestObserver observer=new AbstractResourceProviderTest.TestObserver();
((ObservableResourceProvider)provider).addObserver(observer);
Predicate predicate=new PredicateBuilder().property(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID).equals(clusterName).and().property(ServiceResourceProvider.SERVICE_SERVICE_NAME_PROPERTY_ID).equals(serviceName).toPredicate();
provider.deleteResources(predicate);
ResourceProviderEvent lastEvent=observer.getLastEvent();
Assert.assertNotNull(lastEvent);
Assert.assertEquals(Resource.Type.Service,lastEvent.getResourceType());
Assert.assertEquals(ResourceProviderEvent.Type.Delete,lastEvent.getType());
Assert.assertEquals(predicate,lastEvent.getPredicate());
Assert.assertNull(lastEvent.getRequest());
verify(managementController,clusters,cluster,service,component1.Component,component2.Component,component3.Component);
}
Class: org.apache.ambari.server.controller.internal.SettingResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier entityCapture=Capture.newInstance();
Request request=createRequest(entity);
expect(dao.findByName(entity.getName())).andReturn(null);
dao.create(capture(entityCapture));
mockControl.replay();
RequestStatus response=resourceProvider.createResources(request);
assertEquals(RequestStatus.Status.Complete,response.getStatus());
Set associatedResources=response.getAssociatedResources();
assertEquals(1,associatedResources.size());
SettingEntity capturedEntity=entityCapture.getValue();
assertEquals(entity.getName(),capturedEntity.getName());
assertEquals(entity.getContent(),capturedEntity.getContent());
assertEquals(entity.getSettingType(),capturedEntity.getSettingType());
assertEquals(AuthorizationHelper.getAuthenticatedName(),capturedEntity.getUpdatedBy());
}
InternalCallVerifier EqualityVerifier response=resourceProvider.getResources(request,null);
assertEquals(2,response.size());
Map resourceMap=new HashMap<>();
Iterator resourceIterator=response.iterator();
Resource nextResource=resourceIterator.next();
resourceMap.put(nextResource.getPropertyValue(SETTING_NAME_PROPERTY_ID),nextResource);
nextResource=resourceIterator.next();
resourceMap.put(nextResource.getPropertyValue(SETTING_NAME_PROPERTY_ID),nextResource);
assertEqualsEntityAndResource(entity1,resourceMap.get(entity1.getName()));
assertEqualsEntityAndResource(entity2,resourceMap.get(entity2.getName()));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier capture=Capture.newInstance();
expect(dao.findByName(name)).andReturn(oldEntity);
expect(dao.merge(capture(capture))).andReturn(updatedEntity);
mockControl.replay();
RequestStatus response=resourceProvider.updateResources(updateRequest(updatedEntity),predicate);
SettingEntity capturedEntity=capture.getValue();
assertEquals(RequestStatus.Status.Complete,response.getStatus());
assertEquals(updatedEntity.getId(),capturedEntity.getId());
assertEquals(updatedEntity.getName(),capturedEntity.getName());
assertEquals(updatedEntity.getSettingType(),capturedEntity.getSettingType());
assertEquals(updatedEntity.getContent(),capturedEntity.getContent());
assertEquals(AuthorizationHelper.getAuthenticatedName(),capturedEntity.getUpdatedBy());
}
InternalCallVerifier EqualityVerifier response=resourceProvider.getResources(request,null);
assertEquals(2,response.size());
Map resourceMap=new HashMap<>();
Iterator resourceIterator=response.iterator();
Resource nextResource=resourceIterator.next();
resourceMap.put(nextResource.getPropertyValue(SETTING_NAME_PROPERTY_ID),nextResource);
nextResource=resourceIterator.next();
resourceMap.put(nextResource.getPropertyValue(SETTING_NAME_PROPERTY_ID),nextResource);
assertEqualsEntityAndResource(entity1,resourceMap.get(entity1.getName()));
assertEqualsEntityAndResource(entity2,resourceMap.get(entity2.getName()));
}
Class: org.apache.ambari.server.controller.internal.SimplifyingPredicateVisitorTest InternalCallVerifier EqualityVerifier > propertiesCapture=new Capture>();
SimplifyingPredicateVisitor visitor=new SimplifyingPredicateVisitor(provider);
expect(provider.checkPropertyIds(capture(propertiesCapture))).andReturn(Collections.emptySet()).anyTimes();
replay(provider);
PredicateHelper.visit(PREDICATE_1,visitor);
List simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(1,simplifiedPredicates.size());
Assert.assertEquals(PREDICATE_1,simplifiedPredicates.get(0));
Set setProps=propertiesCapture.getValue();
assertEquals(1,setProps.size());
assertEquals(PROPERTY_A,setProps.iterator().next());
PredicateHelper.visit(PREDICATE_3,visitor);
simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(1,simplifiedPredicates.size());
Assert.assertEquals(PREDICATE_3,simplifiedPredicates.get(0));
PredicateHelper.visit(PREDICATE_4,visitor);
simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(2,simplifiedPredicates.size());
Assert.assertEquals(PREDICATE_1,simplifiedPredicates.get(0));
Assert.assertEquals(PREDICATE_2,simplifiedPredicates.get(1));
PredicateHelper.visit(PREDICATE_6,visitor);
simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(3,simplifiedPredicates.size());
Assert.assertEquals(PREDICATE_5,simplifiedPredicates.get(0));
Assert.assertEquals(PREDICATE_1,simplifiedPredicates.get(1));
Assert.assertEquals(PREDICATE_2,simplifiedPredicates.get(2));
PredicateHelper.visit(PREDICATE_8,visitor);
simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(4,simplifiedPredicates.size());
Assert.assertEquals(PREDICATE_5,simplifiedPredicates.get(0));
Assert.assertEquals(PREDICATE_1,simplifiedPredicates.get(1));
Assert.assertEquals(PREDICATE_2,simplifiedPredicates.get(2));
Assert.assertEquals(PREDICATE_7,simplifiedPredicates.get(3));
PredicateHelper.visit(PREDICATE_9,visitor);
simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(4,simplifiedPredicates.size());
PredicateHelper.visit(PREDICATE_11,visitor);
simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(4,simplifiedPredicates.size());
PredicateHelper.visit(PREDICATE_16,visitor);
simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(1,simplifiedPredicates.size());
Assert.assertEquals(PREDICATE_16,simplifiedPredicates.get(0));
verify(provider);
reset(provider);
expect(provider.checkPropertyIds(capture(propertiesCapture))).andReturn(Collections.emptySet());
expect(provider.checkPropertyIds(capture(propertiesCapture))).andReturn(Collections.singleton(PROPERTY_D));
replay(provider);
PredicateHelper.visit(PREDICATE_13,visitor);
simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(1,simplifiedPredicates.size());
Assert.assertEquals(PREDICATE_1,simplifiedPredicates.get(0));
verify(provider);
reset(provider);
expect(provider.checkPropertyIds(capture(propertiesCapture))).andReturn(Collections.emptySet()).anyTimes();
replay(provider);
PredicateHelper.visit(PREDICATE_15,visitor);
simplifiedPredicates=visitor.getSimplifiedPredicates();
Assert.assertEquals(1,simplifiedPredicates.size());
Assert.assertEquals(PREDICATE_1,simplifiedPredicates.get(0));
verify(provider);
}
Class: org.apache.ambari.server.controller.internal.StackAdvisorResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier keyPropertyIds=Collections.emptyMap();
Set propertyIds=Collections.emptySet();
AmbariManagementController ambariManagementController=mock(AmbariManagementController.class);
RecommendationResourceProvider provider=new RecommendationResourceProvider(propertyIds,keyPropertyIds,ambariManagementController);
Request request=mock(Request.class);
Set> propertiesSet=new HashSet>();
Map propertiesMap=new HashMap();
propertiesMap.put(CONFIGURATIONS_PROPERTY_ID + "site/properties/string_prop","string");
List array=new ArrayList();
array.add("array1");
array.add("array2");
propertiesMap.put(CONFIGURATIONS_PROPERTY_ID + "site/properties/array_prop",array);
propertiesSet.add(propertiesMap);
doReturn(propertiesSet).when(request).getProperties();
Map>> calculatedConfigurations=provider.calculateConfigurations(request);
assertNotNull(calculatedConfigurations);
assertEquals(1,calculatedConfigurations.size());
Map> site=calculatedConfigurations.get("site");
assertNotNull(site);
assertEquals(1,site.size());
Map properties=site.get("properties");
assertNotNull(properties);
assertEquals(2,properties.size());
assertEquals("string",properties.get("string_prop"));
assertEquals("[array1, array2]",properties.get("array_prop"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier keyPropertyIds=Collections.emptyMap();
Set propertyIds=Collections.emptySet();
AmbariManagementController ambariManagementController=mock(AmbariManagementController.class);
RecommendationResourceProvider provider=new RecommendationResourceProvider(propertyIds,keyPropertyIds,ambariManagementController);
Request request=mock(Request.class);
Set> propertiesSet=new HashSet>();
Map propertiesMap=new HashMap();
propertiesMap.put(CONFIGURATIONS_PROPERTY_ID + "site/properties/string_prop",null);
List array=new ArrayList();
array.add("array1");
array.add("array2");
propertiesMap.put(CONFIGURATIONS_PROPERTY_ID + "site/properties/array_prop",array);
propertiesSet.add(propertiesMap);
doReturn(propertiesSet).when(request).getProperties();
Map>> calculatedConfigurations=provider.calculateConfigurations(request);
assertNotNull(calculatedConfigurations);
assertEquals(1,calculatedConfigurations.size());
Map> site=calculatedConfigurations.get("site");
assertNotNull(site);
assertEquals(1,site.size());
Map properties=site.get("properties");
assertNotNull(properties);
assertEquals("[array1, array2]",properties.get("array_prop"));
assertFalse(properties.containsKey("string_prop"));
}
Class: org.apache.ambari.server.controller.internal.StackArtifactResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier propertyIds=new HashSet();
propertyIds.add(ARTIFACT_NAME_PROPERTY_ID);
propertyIds.add(STACK_NAME_PROPERTY_ID);
propertyIds.add(STACK_VERSION_PROPERTY_ID);
propertyIds.add(STACK_SERVICE_NAME_PROPERTY_ID);
propertyIds.add(ARTIFACT_DATA_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Predicate predicate=new PredicateBuilder().property(ARTIFACT_NAME_PROPERTY_ID).equals("widgets_descriptor").and().property(STACK_NAME_PROPERTY_ID).equals("OTHER").and().property(STACK_VERSION_PROPERTY_ID).equals("2.0").and().property(STACK_SERVICE_NAME_PROPERTY_ID).equals("HBASE").toPredicate();
Set resources=resourceProvider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Map> propertyMap=resource.getPropertiesMap();
Map descriptor=propertyMap.get(ARTIFACT_DATA_PROPERTY_ID);
Assert.assertNotNull(descriptor);
Assert.assertEquals(1,((List)descriptor.get("layouts")).size());
WidgetLayout layout=((List)descriptor.get("layouts")).iterator().next();
Assert.assertEquals("default_hbase_layout",layout.getLayoutName());
Assert.assertEquals("HBASE_SUMMARY",layout.getSectionName());
Assert.assertEquals(5,layout.getWidgetLayoutInfoList().size());
verify(managementController);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier propertyIds=new HashSet();
propertyIds.add(ARTIFACT_NAME_PROPERTY_ID);
propertyIds.add(STACK_NAME_PROPERTY_ID);
propertyIds.add(STACK_VERSION_PROPERTY_ID);
propertyIds.add(STACK_SERVICE_NAME_PROPERTY_ID);
propertyIds.add(ARTIFACT_DATA_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Predicate predicate=new PredicateBuilder().property(ARTIFACT_NAME_PROPERTY_ID).equals("metrics_descriptor").and().property(STACK_NAME_PROPERTY_ID).equals("OTHER").and().property(STACK_VERSION_PROPERTY_ID).equals("1.0").and().property(STACK_SERVICE_NAME_PROPERTY_ID).equals("HDFS").toPredicate();
Set resources=resourceProvider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Map> propertyMap=resource.getPropertiesMap();
Map descriptor=propertyMap.get(ARTIFACT_DATA_PROPERTY_ID + "/HDFS/DATANODE");
Assert.assertNotNull(descriptor);
Assert.assertEquals(1,((ArrayList)descriptor.get("Component")).size());
MetricDefinition md=(MetricDefinition)((ArrayList)descriptor.get("Component")).iterator().next();
Metric m1=md.getMetrics().get("metrics/dfs/datanode/heartBeats_avg_time");
Metric m2=md.getMetrics().get("metrics/rpc/closeRegion_num_ops");
Assert.assertEquals(326,md.getMetrics().size());
Assert.assertTrue(m1.isAmsHostMetric());
Assert.assertEquals("unitless",m1.getUnit());
Assert.assertFalse(m2.isAmsHostMetric());
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.StackConfigurationDependencyResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier allResponse=new HashSet();
allResponse.add(new StackConfigurationDependencyResponse("depName","depType"));
expect(managementController.getStackConfigurationDependencies(AbstractResourceProviderTest.Matcher.getStackConfigurationDependencyRequestSet(null,null,null,null,null))).andReturn(allResponse).times(1);
replay(managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(StackConfigurationDependencyResourceProvider.STACK_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationDependencyResourceProvider.STACK_VERSION_PROPERTY_ID);
propertyIds.add(StackConfigurationDependencyResourceProvider.SERVICE_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationDependencyResourceProvider.PROPERTY_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationDependencyResourceProvider.DEPENDENCY_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationDependencyResourceProvider.DEPENDENCY_TYPE_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,null);
Assert.assertEquals(allResponse.size(),resources.size());
for ( Resource resource : resources) {
String dependencyName=(String)resource.getPropertyValue(StackConfigurationDependencyResourceProvider.DEPENDENCY_NAME_PROPERTY_ID);
String dependencyType=(String)resource.getPropertyValue(StackConfigurationDependencyResourceProvider.DEPENDENCY_TYPE_PROPERTY_ID);
Assert.assertEquals("depName",dependencyName);
Assert.assertEquals("depType",dependencyType);
}
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.StackConfigurationResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier attributes=new HashMap();
Resource.Type type=Resource.Type.StackConfiguration;
AmbariManagementController managementController=createMock(AmbariManagementController.class);
Set allResponse=new HashSet();
allResponse.add(new StackConfigurationResponse(PROPERTY_NAME,PROPERTY_VALUE,PROPERTY_DESC,TYPE,attributes));
expect(managementController.getStackConfigurations(AbstractResourceProviderTest.Matcher.getStackConfigurationRequestSet(null,null,null,null))).andReturn(allResponse).times(1);
replay(managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(StackConfigurationResourceProvider.STACK_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.STACK_VERSION_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.SERVICE_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_VALUE_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_DESCRIPTION_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_TYPE_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_FINAL_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,null);
Assert.assertEquals(allResponse.size(),resources.size());
for ( Resource resource : resources) {
String propertyName=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_NAME_PROPERTY_ID);
String propertyValue=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_VALUE_PROPERTY_ID);
String propertyDesc=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_DESCRIPTION_PROPERTY_ID);
String propertyType=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_TYPE_PROPERTY_ID);
String propertyIsFinal=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_FINAL_PROPERTY_ID);
Assert.assertEquals(PROPERTY_NAME,propertyName);
Assert.assertEquals(PROPERTY_VALUE,propertyValue);
Assert.assertEquals(PROPERTY_DESC,propertyDesc);
Assert.assertEquals(TYPE,propertyType);
Assert.assertEquals("false",propertyIsFinal);
}
verify(managementController);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier attributes=new HashMap();
attributes.put("final","true");
Resource.Type type=Resource.Type.StackConfiguration;
AmbariManagementController managementController=createMock(AmbariManagementController.class);
Set allResponse=new HashSet();
allResponse.add(new StackConfigurationResponse(PROPERTY_NAME,PROPERTY_VALUE,PROPERTY_DESC,TYPE,attributes));
expect(managementController.getStackConfigurations(AbstractResourceProviderTest.Matcher.getStackConfigurationRequestSet(null,null,null,null))).andReturn(allResponse).times(1);
replay(managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(StackConfigurationResourceProvider.STACK_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.STACK_VERSION_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.SERVICE_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_NAME_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_VALUE_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_DESCRIPTION_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_TYPE_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_FINAL_PROPERTY_ID);
propertyIds.add(StackConfigurationResourceProvider.PROPERTY_DEPENDS_ON_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,null);
Assert.assertEquals(allResponse.size(),resources.size());
for ( Resource resource : resources) {
String propertyName=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_NAME_PROPERTY_ID);
String propertyValue=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_VALUE_PROPERTY_ID);
String propertyDesc=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_DESCRIPTION_PROPERTY_ID);
String propertyType=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_TYPE_PROPERTY_ID);
String propertyIsFinal=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_FINAL_PROPERTY_ID);
String propertyDependencies=(String)resource.getPropertyValue(StackConfigurationResourceProvider.PROPERTY_DEPENDS_ON_PROPERTY_ID);
Assert.assertEquals(PROPERTY_NAME,propertyName);
Assert.assertEquals(PROPERTY_VALUE,propertyValue);
Assert.assertEquals(PROPERTY_DESC,propertyDesc);
Assert.assertEquals(TYPE,propertyType);
Assert.assertEquals("true",propertyIsFinal);
Assert.assertNull(propertyDependencies);
}
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.StackDependencyResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier (StackDependencyResourceProvider.COMPONENT_NAME_ID,"comp_name");
Predicate depServicePredicate=new EqualsPredicate(StackDependencyResourceProvider.DEPENDENT_SERVICE_NAME_ID,"dep_service_name");
Predicate depCompPredicate=new EqualsPredicate(StackDependencyResourceProvider.DEPENDENT_COMPONENT_NAME_ID,"dep_comp_name");
Predicate stackNamePredicate=new EqualsPredicate(StackDependencyResourceProvider.STACK_NAME_ID,"stack_name");
Predicate stackVersionPredicate=new EqualsPredicate(StackDependencyResourceProvider.STACK_VERSION_ID,"stack_version");
Predicate andPredicate=new AndPredicate(namePredicate,depServicePredicate,depCompPredicate,stackNamePredicate,stackVersionPredicate);
expect(metaInfo.getComponentDependency("stack_name","stack_version","dep_service_name","dep_comp_name","comp_name")).andReturn(dependencyInfo);
replay(metaInfo,request);
ResourceProvider provider=createProvider();
Set resources=provider.getResources(request,andPredicate);
verify(metaInfo);
assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
assertEquals("cluster",resource.getPropertyValue(StackDependencyResourceProvider.SCOPE_ID));
assertEquals("comp_name",resource.getPropertyValue(StackDependencyResourceProvider.COMPONENT_NAME_ID));
assertEquals("service_name",resource.getPropertyValue(StackDependencyResourceProvider.SERVICE_NAME_ID));
assertEquals("dep_service_name",resource.getPropertyValue(StackDependencyResourceProvider.DEPENDENT_SERVICE_NAME_ID));
assertEquals("dep_comp_name",resource.getPropertyValue(StackDependencyResourceProvider.DEPENDENT_COMPONENT_NAME_ID));
assertEquals("stack_name",resource.getPropertyValue(StackDependencyResourceProvider.STACK_NAME_ID));
assertEquals("stack_version",resource.getPropertyValue(StackDependencyResourceProvider.STACK_VERSION_ID));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier (StackDependencyResourceProvider.COMPONENT_NAME_ID,"comp_name");
Predicate name2Predicate=new EqualsPredicate(StackDependencyResourceProvider.COMPONENT_NAME_ID,"comp_name2");
Predicate depServicePredicate=new EqualsPredicate(StackDependencyResourceProvider.DEPENDENT_SERVICE_NAME_ID,"dep_service_name");
Predicate depCompPredicate=new EqualsPredicate(StackDependencyResourceProvider.DEPENDENT_COMPONENT_NAME_ID,"dep_comp_name");
Predicate stackNamePredicate=new EqualsPredicate(StackDependencyResourceProvider.STACK_NAME_ID,"stack_name");
Predicate stackVersionPredicate=new EqualsPredicate(StackDependencyResourceProvider.STACK_VERSION_ID,"stack_version");
Predicate andPredicate1=new AndPredicate(namePredicate,depServicePredicate,depCompPredicate,stackNamePredicate,stackVersionPredicate);
Predicate andPredicate2=new AndPredicate(name2Predicate,depServicePredicate,depCompPredicate,stackNamePredicate,stackVersionPredicate);
Predicate orPredicate=new OrPredicate(andPredicate1,andPredicate2);
expect(metaInfo.getComponentDependency("stack_name","stack_version","dep_service_name","dep_comp_name","comp_name")).andReturn(dependencyInfo);
expect(metaInfo.getComponentDependency("stack_name","stack_version","dep_service_name","dep_comp_name","comp_name2")).andThrow(new StackAccessException("test"));
replay(metaInfo,request);
ResourceProvider provider=createProvider();
Set resources=provider.getResources(request,orPredicate);
verify(metaInfo);
assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
assertEquals("cluster",resource.getPropertyValue(StackDependencyResourceProvider.SCOPE_ID));
assertEquals("comp_name",resource.getPropertyValue(StackDependencyResourceProvider.COMPONENT_NAME_ID));
assertEquals("service_name",resource.getPropertyValue(StackDependencyResourceProvider.SERVICE_NAME_ID));
assertEquals("dep_service_name",resource.getPropertyValue(StackDependencyResourceProvider.DEPENDENT_SERVICE_NAME_ID));
assertEquals("dep_comp_name",resource.getPropertyValue(StackDependencyResourceProvider.DEPENDENT_COMPONENT_NAME_ID));
assertEquals("stack_name",resource.getPropertyValue(StackDependencyResourceProvider.STACK_NAME_ID));
assertEquals("stack_version",resource.getPropertyValue(StackDependencyResourceProvider.STACK_VERSION_ID));
}
Class: org.apache.ambari.server.controller.internal.StackLevelConfigurationResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier attributes=new HashMap();
Resource.Type type=Resource.Type.StackLevelConfiguration;
AmbariManagementController managementController=createMock(AmbariManagementController.class);
Set allResponse=new HashSet();
allResponse.add(new StackConfigurationResponse(PROPERTY_NAME,PROPERTY_VALUE,PROPERTY_DESC,TYPE,attributes));
expect(managementController.getStackLevelConfigurations(AbstractResourceProviderTest.Matcher.getStackLevelConfigurationRequestSet(null,null,null))).andReturn(allResponse).times(1);
replay(managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(StackLevelConfigurationResourceProvider.STACK_NAME_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.STACK_VERSION_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_NAME_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_VALUE_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_DESCRIPTION_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_TYPE_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_FINAL_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,null);
Assert.assertEquals(allResponse.size(),resources.size());
for ( Resource resource : resources) {
String propertyName=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_NAME_PROPERTY_ID);
String propertyValue=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_VALUE_PROPERTY_ID);
String propertyDesc=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_DESCRIPTION_PROPERTY_ID);
String propertyType=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_TYPE_PROPERTY_ID);
String propertyIsFinal=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_FINAL_PROPERTY_ID);
Assert.assertEquals(PROPERTY_NAME,propertyName);
Assert.assertEquals(PROPERTY_VALUE,propertyValue);
Assert.assertEquals(PROPERTY_DESC,propertyDesc);
Assert.assertEquals(TYPE,propertyType);
Assert.assertEquals("false",propertyIsFinal);
}
verify(managementController);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier attributes=new HashMap();
attributes.put("final","true");
Resource.Type type=Resource.Type.StackLevelConfiguration;
AmbariManagementController managementController=createMock(AmbariManagementController.class);
Set allResponse=new HashSet();
allResponse.add(new StackConfigurationResponse(PROPERTY_NAME,PROPERTY_VALUE,PROPERTY_DESC,TYPE,attributes));
expect(managementController.getStackLevelConfigurations(AbstractResourceProviderTest.Matcher.getStackLevelConfigurationRequestSet(null,null,null))).andReturn(allResponse).times(1);
replay(managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(StackLevelConfigurationResourceProvider.STACK_NAME_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.STACK_VERSION_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_NAME_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_VALUE_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_DESCRIPTION_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_TYPE_PROPERTY_ID);
propertyIds.add(StackLevelConfigurationResourceProvider.PROPERTY_FINAL_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,null);
Assert.assertEquals(allResponse.size(),resources.size());
for ( Resource resource : resources) {
String propertyName=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_NAME_PROPERTY_ID);
String propertyValue=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_VALUE_PROPERTY_ID);
String propertyDesc=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_DESCRIPTION_PROPERTY_ID);
String propertyType=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_TYPE_PROPERTY_ID);
String propertyIsFinal=(String)resource.getPropertyValue(StackLevelConfigurationResourceProvider.PROPERTY_FINAL_PROPERTY_ID);
Assert.assertEquals(PROPERTY_NAME,propertyName);
Assert.assertEquals(PROPERTY_VALUE,propertyValue);
Assert.assertEquals(PROPERTY_DESC,propertyDesc);
Assert.assertEquals(TYPE,propertyType);
Assert.assertEquals("true",propertyIsFinal);
}
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.StackResourceProviderTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier allResponse=new HashSet();
allResponse.add(new StackResponse("Stack1"));
allResponse.add(new StackResponse("Stack2"));
expect(managementController.getStacks(EasyMock.>anyObject())).andReturn(allResponse).once();
replay(managementController);
ResourceProvider provider=AbstractControllerResourceProvider.getResourceProvider(type,PropertyHelper.getPropertyIds(type),PropertyHelper.getKeyPropertyIds(type),managementController);
Set propertyIds=new HashSet();
propertyIds.add(StackResourceProvider.STACK_NAME_PROPERTY_ID);
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,null);
Assert.assertEquals(2,resources.size());
Set stackNames=new HashSet();
stackNames.add("Stack1");
stackNames.add("Stack2");
for ( Resource resource : resources) {
String stackName=(String)resource.getPropertyValue(StackResourceProvider.STACK_NAME_PROPERTY_ID);
Assert.assertTrue(stackNames.contains(stackName));
}
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.StackServiceResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=stackServiceResourceProvider.getResources(request,null);
Resource expected=new ResourceImpl(type);
BaseProvider.setResourceProperty(expected,SERVICE_PROPERTIES_PROPERTY_ID,TEST_SERVICE_PROPERTIES,ImmutableSet.of(SERVICE_PROPERTIES_PROPERTY_ID));
assertEquals(ImmutableSet.of(expected),resources);
verify(managementController,stackServiceResponse);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier resources=stackServiceResourceProvider.getResources(request,null);
Map expectedServiceProperties=ImmutableMap.builder().putAll(TEST_SERVICE_PROPERTIES).put(ServiceInfo.DEFAULT_SERVICE_INSTALLABLE_PROPERTY).put(ServiceInfo.DEFAULT_SERVICE_MANAGED_PROPERTY).put(ServiceInfo.DEFAULT_SERVICE_MONITORED_PROPERTY).build();
Resource expected=new ResourceImpl(type);
BaseProvider.setResourceProperty(expected,SERVICE_PROPERTIES_PROPERTY_ID,expectedServiceProperties,ImmutableSet.of(SERVICE_PROPERTIES_PROPERTY_ID));
assertEquals(ImmutableSet.of(expected),resources);
verify(managementController);
}
Class: org.apache.ambari.server.controller.internal.StackTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > stackServiceRequestCapture=new Capture>();
StackServiceResponse stackServiceResponse=createNiceMock(StackServiceResponse.class);
Capture> stackComponentRequestCapture=new Capture>();
StackServiceComponentResponse stackComponentResponse=createNiceMock(StackServiceComponentResponse.class);
Capture> stackConfigurationRequestCapture=new Capture>();
Capture> stackLevelConfigurationRequestCapture=new Capture>();
StackConfigurationResponse stackConfigurationResponse=EasyMock.createNiceMock(StackConfigurationResponse.class);
StackConfigurationResponse stackConfigurationResponse2=EasyMock.createNiceMock(StackConfigurationResponse.class);
expect(controller.getStackServices(capture(stackServiceRequestCapture))).andReturn(Collections.singleton(stackServiceResponse)).anyTimes();
expect(controller.getAmbariMetaInfo()).andReturn(metaInfo).anyTimes();
expect(stackServiceResponse.getServiceName()).andReturn("service1").anyTimes();
expect(stackServiceResponse.getExcludedConfigTypes()).andReturn(Collections.emptySet());
expect(controller.getStackComponents(capture(stackComponentRequestCapture))).andReturn(Collections.singleton(stackComponentResponse)).anyTimes();
expect(stackComponentResponse.getComponentName()).andReturn("component1").anyTimes();
expect(stackComponentResponse.getComponentCategory()).andReturn("test-site.xml").anyTimes();
expect(controller.getStackConfigurations(capture(stackConfigurationRequestCapture))).andReturn(new HashSet(Arrays.asList(stackConfigurationResponse,stackConfigurationResponse2))).anyTimes();
expect(controller.getStackLevelConfigurations(capture(stackLevelConfigurationRequestCapture))).andReturn(Collections.emptySet()).anyTimes();
expect(stackConfigurationResponse.getPropertyName()).andReturn("prop1").anyTimes();
expect(stackConfigurationResponse.getPropertyValue()).andReturn(null).anyTimes();
expect(stackConfigurationResponse.getType()).andReturn("test-site.xml").anyTimes();
expect(stackConfigurationResponse.getPropertyType()).andReturn(Collections.singleton(PropertyInfo.PropertyType.PASSWORD)).anyTimes();
expect(stackConfigurationResponse.getPropertyAttributes()).andReturn(Collections.emptyMap()).anyTimes();
expect(stackConfigurationResponse.isRequired()).andReturn(true).anyTimes();
expect(stackConfigurationResponse2.getPropertyName()).andReturn("prop2").anyTimes();
expect(stackConfigurationResponse2.getPropertyValue()).andReturn(null).anyTimes();
expect(stackConfigurationResponse2.getType()).andReturn("test-site.xml").anyTimes();
expect(stackConfigurationResponse2.getPropertyType()).andReturn(Collections.singleton(PropertyInfo.PropertyType.USER)).anyTimes();
expect(stackConfigurationResponse2.getPropertyAttributes()).andReturn(Collections.emptyMap()).anyTimes();
expect(stackConfigurationResponse2.isRequired()).andReturn(true).anyTimes();
expect(metaInfo.getComponentDependencies("test","1.0","service1","component1")).andReturn(Collections.emptyList()).anyTimes();
replay(controller,stackServiceResponse,stackComponentResponse,stackConfigurationResponse,stackConfigurationResponse2,metaInfo);
Stack stack=new Stack("test","1.0",controller);
Collection requiredPasswordProperties=stack.getRequiredConfigurationProperties("service1",PropertyInfo.PropertyType.PASSWORD);
assertEquals(1,requiredPasswordProperties.size());
Stack.ConfigProperty requiredPasswordConfigProperty=requiredPasswordProperties.iterator().next();
assertEquals("test-site",requiredPasswordConfigProperty.getType());
assertEquals("prop1",requiredPasswordConfigProperty.getName());
assertTrue(requiredPasswordConfigProperty.getPropertyTypes().contains(PropertyInfo.PropertyType.PASSWORD));
StackServiceRequest stackServiceRequest=stackServiceRequestCapture.getValue().iterator().next();
assertEquals("test",stackServiceRequest.getStackName());
assertEquals("1.0",stackServiceRequest.getStackVersion());
StackServiceComponentRequest stackComponentRequest=stackComponentRequestCapture.getValue().iterator().next();
assertEquals("service1",stackComponentRequest.getServiceName());
assertEquals("test",stackComponentRequest.getStackName());
assertEquals("1.0",stackComponentRequest.getStackVersion());
assertNull(stackComponentRequest.getComponentName());
}
InternalCallVerifier IdentityVerifier setOfDependencyInfo=new HashSet();
StackConfigurationResponse mockResponse=mockSupport.createMock(StackConfigurationResponse.class);
expect(mockResponse.getPropertyName()).andReturn("test-property-one");
expect(mockResponse.getPropertyValue()).andReturn("test-value-one");
expect(mockResponse.getPropertyAttributes()).andReturn(Collections.emptyMap());
expect(mockResponse.getPropertyType()).andReturn(Collections.emptySet());
expect(mockResponse.getType()).andReturn("test-type-one");
expect(mockResponse.getDependsOnProperties()).andReturn(setOfDependencyInfo);
mockSupport.replayAll();
Stack.ConfigProperty configProperty=new Stack.ConfigProperty(mockResponse);
assertSame("DependencyInfo was not properly parsed from the stack response object",setOfDependencyInfo,configProperty.getDependsOnProperties());
mockSupport.verifyAll();
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > stackServiceRequestCapture=new Capture>();
StackServiceResponse stackServiceResponse=createNiceMock(StackServiceResponse.class);
Capture> stackComponentRequestCapture=new Capture>();
StackServiceComponentResponse stackComponentResponse=createNiceMock(StackServiceComponentResponse.class);
Capture> stackConfigurationRequestCapture=new Capture>();
Capture> stackLevelConfigurationRequestCapture=new Capture>();
StackConfigurationResponse stackConfigurationResponse=EasyMock.createNiceMock(StackConfigurationResponse.class);
expect(controller.getStackServices(capture(stackServiceRequestCapture))).andReturn(Collections.singleton(stackServiceResponse)).anyTimes();
expect(controller.getAmbariMetaInfo()).andReturn(metaInfo).anyTimes();
expect(stackServiceResponse.getServiceName()).andReturn("service1").anyTimes();
expect(stackServiceResponse.getExcludedConfigTypes()).andReturn(Collections.emptySet());
expect(controller.getStackComponents(capture(stackComponentRequestCapture))).andReturn(Collections.singleton(stackComponentResponse)).anyTimes();
expect(stackComponentResponse.getComponentName()).andReturn("component1").anyTimes();
expect(stackComponentResponse.getComponentCategory()).andReturn("test-site.xml").anyTimes();
expect(controller.getStackConfigurations(capture(stackConfigurationRequestCapture))).andReturn(Collections.singleton(stackConfigurationResponse)).anyTimes();
expect(controller.getStackLevelConfigurations(capture(stackLevelConfigurationRequestCapture))).andReturn(Collections.emptySet()).anyTimes();
expect(stackConfigurationResponse.getPropertyName()).andReturn("prop1").anyTimes();
expect(stackConfigurationResponse.getPropertyValue()).andReturn("prop1Val").anyTimes();
expect(stackConfigurationResponse.getType()).andReturn("test-site.xml").anyTimes();
expect(stackConfigurationResponse.getPropertyType()).andReturn(Collections.emptySet()).anyTimes();
expect(stackConfigurationResponse.getPropertyAttributes()).andReturn(Collections.emptyMap()).anyTimes();
expect(stackConfigurationResponse.isRequired()).andReturn(true).anyTimes();
expect(metaInfo.getComponentDependencies("test","1.0","service1","component1")).andReturn(Collections.emptyList()).anyTimes();
replay(controller,stackServiceResponse,stackComponentResponse,stackConfigurationResponse,metaInfo);
Stack stack=new Stack("test","1.0",controller);
Configuration configuration=stack.getConfiguration(Collections.singleton("service1"));
assertEquals("prop1Val",configuration.getProperties().get("test-site").get("prop1"));
assertEquals("test-site",stack.getRequiredConfigurationProperties("service1").iterator().next().getType());
StackServiceRequest stackServiceRequest=stackServiceRequestCapture.getValue().iterator().next();
assertEquals("test",stackServiceRequest.getStackName());
assertEquals("1.0",stackServiceRequest.getStackVersion());
StackServiceComponentRequest stackComponentRequest=stackComponentRequestCapture.getValue().iterator().next();
assertEquals("service1",stackComponentRequest.getServiceName());
assertEquals("test",stackComponentRequest.getStackName());
assertEquals("1.0",stackComponentRequest.getStackVersion());
assertNull(stackComponentRequest.getComponentName());
}
Class: org.apache.ambari.server.controller.internal.StageResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier entities=getStageEntities(HostRoleStatus.COMPLETED);
expect(dao.findAll(request,predicate)).andReturn(entities);
expect(clusters.getClusterById(anyLong())).andReturn(cluster).anyTimes();
expect(cluster.getClusterName()).andReturn("c1").anyTimes();
replay(dao,clusters,cluster,request,predicate);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals(100.0,resource.getPropertyValue(StageResourceProvider.STAGE_PROGRESS_PERCENT));
Assert.assertEquals(HostRoleStatus.COMPLETED,resource.getPropertyValue(StageResourceProvider.STAGE_STATUS));
Assert.assertEquals(HostRoleStatus.COMPLETED,resource.getPropertyValue(StageResourceProvider.STAGE_DISPLAY_STATUS));
Assert.assertEquals(1000L,resource.getPropertyValue(StageResourceProvider.STAGE_START_TIME));
Assert.assertEquals(2500L,resource.getPropertyValue(StageResourceProvider.STAGE_END_TIME));
verify(dao,clusters,cluster);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier (){
{
put(0L,new HostRoleCommandStatusSummaryDTO(0,1000L,2500L,0,0,1,0,0,0,0,0,0,0,0,1));
}
}
).anyTimes();
replay(hrcDao);
StageResourceProvider provider=new StageResourceProvider(managementController);
Request request=createNiceMock(Request.class);
Predicate predicate=createNiceMock(Predicate.class);
List entities=getStageEntities(HostRoleStatus.SKIPPED_FAILED);
entities.get(0).setSkippable(true);
expect(dao.findAll(request,predicate)).andReturn(entities);
expect(clusters.getClusterById(anyLong())).andReturn(cluster).anyTimes();
expect(cluster.getClusterName()).andReturn("c1").anyTimes();
replay(dao,clusters,cluster,request,predicate);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals(HostRoleStatus.COMPLETED,resource.getPropertyValue(StageResourceProvider.STAGE_STATUS));
Assert.assertEquals(HostRoleStatus.SKIPPED_FAILED,resource.getPropertyValue(StageResourceProvider.STAGE_DISPLAY_STATUS));
verify(dao,clusters,cluster);
}
InternalCallVerifier BooleanVerifier EqualityVerifier IgnoredMethod HybridVerifier entities=getStageEntities(HostRoleStatus.COMPLETED);
expect(dao.findAll(request,predicate)).andReturn(entities);
expect(clusters.getClusterById(anyLong())).andReturn(cluster).anyTimes();
expect(cluster.getClusterName()).andReturn("c1").anyTimes();
replay(dao,clusters,cluster,request,predicate);
QueryResponse response=provider.queryForResources(request,predicate);
Set resources=response.getResources();
Assert.assertEquals(1,resources.size());
Assert.assertFalse(response.isSortedResponse());
Assert.assertFalse(response.isPagedResponse());
Assert.assertEquals(1,response.getTotalResourceCount());
verify(dao,clusters,cluster);
}
Class: org.apache.ambari.server.controller.internal.TargetClusterResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier > propertySet=new HashSet>();
Map properties=new HashMap();
List targetClusterNames=new LinkedList();
targetClusterNames.add("Cluster1");
targetClusterNames.add("Cluster2");
targetClusterNames.add("Cluster3");
Cluster.Interface interface1=new Cluster.Interface("type","endpoint","version");
Cluster.Location location1=new Cluster.Location("name","path");
Cluster targetCluster1=new Cluster("Cluster1","Colo",Collections.singleton(interface1),Collections.singleton(location1),Collections.singletonMap("P1","V1"));
Cluster targetCluster2=new Cluster("Cluster2","Colo",Collections.singleton(interface1),Collections.singleton(location1),Collections.singletonMap("P1","V1"));
Cluster targetCluster3=new Cluster("Cluster3","Colo",Collections.singleton(interface1),Collections.singleton(location1),Collections.singletonMap("P1","V1"));
expect(service.getClusterNames()).andReturn(targetClusterNames);
expect(service.getCluster("Cluster1")).andReturn(targetCluster1);
expect(service.getCluster("Cluster2")).andReturn(targetCluster2);
expect(service.getCluster("Cluster3")).andReturn(targetCluster3);
replay(service);
propertySet.add(properties);
Request request=PropertyHelper.getCreateRequest(propertySet,Collections.emptyMap());
TargetClusterResourceProvider provider=new TargetClusterResourceProvider(service,PropertyHelper.getPropertyIds(Resource.Type.DRTargetCluster),PropertyHelper.getKeyPropertyIds(Resource.Type.DRTargetCluster));
Set resources=provider.getResources(request,null);
Assert.assertEquals(3,resources.size());
verify(service);
}
Class: org.apache.ambari.server.controller.internal.TaskAttemptResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier requestedIds=new HashSet();
requestedIds.add(TaskAttemptResourceProvider.TASK_ATTEMPT_ID_PROPERTY_ID);
Map keyPropertyIds=PropertyHelper.getKeyPropertyIds(Resource.Type.TaskAttempt);
ResourceProvider provider=new TestTaskAttemptResourceProvider(requestedIds,keyPropertyIds);
Request request=PropertyHelper.getReadRequest(requestedIds);
Predicate predicate=new PredicateBuilder().property(TaskAttemptResourceProvider.TASK_ATTEMPT_ID_PROPERTY_ID).equals("taskattempt1").toPredicate();
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String workflowId=(String)resource.getPropertyValue(TaskAttemptResourceProvider.TASK_ATTEMPT_ID_PROPERTY_ID);
Assert.assertEquals("taskattempt1",workflowId);
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier expected=new HashSet();
expected.add(createTaskAttemptResponse("Cluster100","workflow1","job1","taskAttempt1"));
expected.add(createTaskAttemptResponse("Cluster100","workflow2","job2","taskAttempt2"));
expected.add(createTaskAttemptResponse("Cluster100","workflow2","job2","taskAttempt3"));
Resource.Type type=Resource.Type.TaskAttempt;
Set propertyIds=PropertyHelper.getPropertyIds(type);
TaskAttemptFetcher taskAttemptFetcher=createMock(TaskAttemptFetcher.class);
expect(taskAttemptFetcher.fetchTaskAttemptDetails(propertyIds,null,null,"job2",null)).andReturn(expected).once();
replay(taskAttemptFetcher);
Map keyPropertyIds=PropertyHelper.getKeyPropertyIds(type);
ResourceProvider provider=new TaskAttemptResourceProvider(propertyIds,keyPropertyIds,taskAttemptFetcher);
Request request=PropertyHelper.getReadRequest(propertyIds);
Predicate predicate=new PredicateBuilder().property(TaskAttemptResourceProvider.TASK_ATTEMPT_JOB_ID_PROPERTY_ID).equals("job2").toPredicate();
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(3,resources.size());
Set names=new HashSet();
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(TaskAttemptResourceProvider.TASK_ATTEMPT_CLUSTER_NAME_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
names.add((String)resource.getPropertyValue(TaskAttemptResourceProvider.TASK_ATTEMPT_ID_PROPERTY_ID));
}
for ( Resource resource : expected) {
Assert.assertTrue(names.contains(resource.getPropertyValue(TaskAttemptResourceProvider.TASK_ATTEMPT_ID_PROPERTY_ID)));
}
verify(taskAttemptFetcher);
}
Class: org.apache.ambari.server.controller.internal.TaskResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier entities=new ArrayList<>();
List commands=new ArrayList<>();
HostRoleCommandEntity hostRoleCommandEntity=new HostRoleCommandEntity();
hostRoleCommandEntity.setRequestId(100L);
hostRoleCommandEntity.setTaskId(100L);
hostRoleCommandEntity.setStageId(100L);
hostRoleCommandEntity.setRole(Role.DATANODE);
hostRoleCommandEntity.setCustomCommandName("customCommandName");
hostRoleCommandEntity.setCommandDetail("commandDetail");
commands.add(new HostRoleCommand(hostRoleCommandEntity,hostDAO,executionCommandDAO));
expect(hostRoleCommandDAO.findAll(EasyMock.anyObject(Request.class),EasyMock.anyObject(Predicate.class))).andReturn(entities).once();
expect(topologyManager.getTasks(EasyMock.anyLong())).andReturn(commands).once();
replay(hostRoleCommandDAO,topologyManager);
Set propertyIds=new HashSet();
propertyIds.add(TaskResourceProvider.TASK_ID_PROPERTY_ID);
propertyIds.add(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID);
propertyIds.add(TaskResourceProvider.TASK_COMMAND_DET_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(TaskResourceProvider.TASK_ID_PROPERTY_ID).equals("100").and().property(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID).equals("100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
long taskId=(Long)resource.getPropertyValue(TaskResourceProvider.TASK_ID_PROPERTY_ID);
Assert.assertEquals(100L,taskId);
Assert.assertEquals(null,resource.getPropertyValue(TaskResourceProvider.TASK_CUST_CMD_NAME_PROPERTY_ID));
Assert.assertEquals("commandDetail",resource.getPropertyValue(TaskResourceProvider.TASK_COMMAND_DET_PROPERTY_ID));
}
verify(hostRoleCommandDAO,topologyManager);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier entities=new ArrayList<>();
HostRoleCommandEntity hostRoleCommandEntity=new HostRoleCommandEntity();
hostRoleCommandEntity.setRequestId(100L);
hostRoleCommandEntity.setTaskId(100L);
hostRoleCommandEntity.setStageId(100L);
hostRoleCommandEntity.setRole(Role.DATANODE);
hostRoleCommandEntity.setCustomCommandName("customCommandName");
hostRoleCommandEntity.setCommandDetail("commandDetail");
entities.add(hostRoleCommandEntity);
expect(hostRoleCommandDAO.findAll(EasyMock.anyObject(Request.class),EasyMock.anyObject(Predicate.class))).andReturn(entities).once();
replay(hostRoleCommandDAO);
Set propertyIds=new HashSet();
propertyIds.add(TaskResourceProvider.TASK_ID_PROPERTY_ID);
propertyIds.add(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID);
propertyIds.add(TaskResourceProvider.TASK_COMMAND_DET_PROPERTY_ID);
Predicate predicate=new PredicateBuilder().property(TaskResourceProvider.TASK_ID_PROPERTY_ID).equals("100").and().property(TaskResourceProvider.TASK_REQUEST_ID_PROPERTY_ID).equals("100").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
long taskId=(Long)resource.getPropertyValue(TaskResourceProvider.TASK_ID_PROPERTY_ID);
Assert.assertEquals(100L,taskId);
Assert.assertEquals(null,resource.getPropertyValue(TaskResourceProvider.TASK_CUST_CMD_NAME_PROPERTY_ID));
Assert.assertEquals("commandDetail",resource.getPropertyValue(TaskResourceProvider.TASK_COMMAND_DET_PROPERTY_ID));
}
verify(hostRoleCommandDAO);
}
APIUtilityVerifier InternalCallVerifier NullVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.controller.internal.URLStreamProviderTest InternalCallVerifier EqualityVerifier > headerMap=new HashMap>();
headerMap.put("Header1",Collections.singletonList("value"));
headerMap.put("Cookie",Collections.singletonList("FOO=bar"));
expect(appCookieManager.getCachedAppCookie("spec")).andReturn("APPCOOKIE=abcdef");
connection.setConnectTimeout(1000);
connection.setReadTimeout(1000);
connection.setRequestMethod("GET");
connection.setRequestProperty("Header1","value");
connection.setRequestProperty("Cookie","FOO=bar; APPCOOKIE=abcdef");
replay(urlStreamProvider,connection,appCookieManager);
Assert.assertEquals(connection,urlStreamProvider.processURL("spec","GET",(String)null,headerMap));
verify(urlStreamProvider,connection,appCookieManager);
}
Class: org.apache.ambari.server.controller.internal.UpgradeResourceProviderHDP22Test APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.4.2");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
upgradeResourceProvider.createResources(request);
List upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(1,upgrades.size());
UpgradeEntity upgrade=upgrades.get(0);
assertEquals("upgrade_test",upgrade.getUpgradePackage());
assertEquals(3,upgrade.getUpgradeGroups().size());
UpgradeGroupEntity group=upgrade.getUpgradeGroups().get(2);
assertEquals(3,group.getItems().size());
group=upgrade.getUpgradeGroups().get(0);
assertEquals(2,group.getItems().size());
UpgradeItemEntity item=group.getItems().get(1);
assertEquals("Value is set for the source stack upgrade pack","Goo",item.getText());
assertTrue(cluster.getDesiredConfigs().containsKey("hive-site"));
StackId newStack=cluster.getDesiredStackVersion();
assertTrue(oldStack.equals(newStack));
for ( Service s : cluster.getServices().values()) {
assertEquals(newStack,s.getDesiredStackVersion());
for ( ServiceComponent sc : s.getServiceComponents().values()) {
assertEquals(newStack,sc.getDesiredStackVersion());
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
assertEquals(newStack,sch.getDesiredStackVersion());
}
}
}
assertEquals(configTagVersion1,cluster.getDesiredConfigByType("hive-site").getTag());
final Config newConfig=new ConfigImpl("hive-site");
newConfig.setProperties(configTagVersion2Properties);
newConfig.setTag(configTagVersion2);
Set desiredConfigs=new HashSet(){
{
add(newConfig);
}
}
;
cluster.addConfig(newConfig);
cluster.addDesiredConfig("admin",desiredConfigs);
assertEquals(configTagVersion2,cluster.getDesiredConfigByType("hive-site").getTag());
Gson gson=new Gson();
List currentExecutionCommands=injector.getInstance(ExecutionCommandDAO.class).findAll();
for ( ExecutionCommandEntity ece : currentExecutionCommands) {
String executionCommandJson=new String(ece.getCommand());
Map commandMap=gson.>fromJson(executionCommandJson,Map.class);
Set roleCommandsThatMustHaveRefresh=new HashSet();
roleCommandsThatMustHaveRefresh.add("SERVICE_CHECK");
roleCommandsThatMustHaveRefresh.add("RESTART");
roleCommandsThatMustHaveRefresh.add("ACTIONEXECUTE");
String roleCommand=(String)commandMap.get("roleCommand");
if (roleCommandsThatMustHaveRefresh.contains(roleCommand)) {
assertTrue(commandMap.containsKey(KeyNames.REFRESH_CONFIG_TAGS_BEFORE_EXECUTION));
Object object=commandMap.get(KeyNames.REFRESH_CONFIG_TAGS_BEFORE_EXECUTION);
assertTrue(object instanceof List);
@SuppressWarnings("unchecked") List tags=(List)commandMap.get(KeyNames.REFRESH_CONFIG_TAGS_BEFORE_EXECUTION);
assertEquals(1,tags.size());
assertEquals("*",tags.get(0));
ExecutionCommandWrapper executionCommandWrapper=new ExecutionCommandWrapper(executionCommandJson);
ExecutionCommand executionCommand=executionCommandWrapper.getExecutionCommand();
Map> configurationTags=executionCommand.getConfigurationTags();
assertEquals(configTagVersion2,configurationTags.get("hive-site").get("tag"));
Map> configurations=executionCommand.getConfigurations();
assertEquals("10010",configurations.get("hive-site").get("hive.server2.thrift.port"));
}
}
}
Class: org.apache.ambari.server.controller.internal.UpgradeResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(0,upgrades.size());
Map requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.1.1.1");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_test");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_FAILURES,"true");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_SC_FAILURES,"true");
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
RequestStatus status=upgradeResourceProvider.createResources(request);
assertNotNull(status);
Set propertyIds=new HashSet();
propertyIds.add("Upgrade");
Predicate predicate=new PredicateBuilder().property(UpgradeResourceProvider.UPGRADE_REQUEST_ID).equals("1").and().property(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME).equals("c1").toPredicate();
request=PropertyHelper.getReadRequest(propertyIds);
Set resources=upgradeResourceProvider.getResources(request,predicate);
assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
assertEquals(true,resource.getPropertyValue(UpgradeResourceProvider.UPGRADE_SKIP_FAILURES));
assertEquals(true,resource.getPropertyValue(UpgradeResourceProvider.UPGRADE_SKIP_SC_FAILURES));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.0.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_test");
requestProps.put(UpgradeResourceProvider.UPGRADE_TYPE,UpgradeType.ROLLING.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_MANUAL_VERIFICATION,Boolean.TRUE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,Boolean.TRUE.toString());
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
upgradeResourceProvider.createResources(request);
List upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(1,upgrades.size());
UpgradeEntity entity=upgrades.get(0);
assertEquals(cluster.getClusterId(),entity.getClusterId().longValue());
List upgradeGroups=entity.getUpgradeGroups();
assertEquals(2,upgradeGroups.size());
UpgradeGroupEntity zookeeperGroup=upgradeGroups.get(0);
assertEquals("ZOOKEEPER",zookeeperGroup.getName());
List zookeeperUpgradeItems=zookeeperGroup.getItems();
assertEquals(3,zookeeperUpgradeItems.size());
assertEquals("Restarting ZooKeeper Server on h1",zookeeperUpgradeItems.get(0).getText());
assertEquals("Skipping Configuration Task 2.2.0",zookeeperUpgradeItems.get(1).getText());
assertEquals("Service Check ZooKeeper",zookeeperUpgradeItems.get(2).getText());
UpgradeGroupEntity postClusterGroup=upgradeGroups.get(1);
assertEquals("POST_CLUSTER",postClusterGroup.getName());
List postClusterUpgradeItems=postClusterGroup.getItems();
assertEquals(1,postClusterUpgradeItems.size());
assertEquals("Save Cluster State",postClusterUpgradeItems.get(0).getText());
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier requestProps=new HashMap<>();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.1.1.1");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_test");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
upgradeResourceProvider.createResources(request);
List upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(1,upgrades.size());
requestProps=new HashMap<>();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_test");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
try {
upgradeResourceProvider.createResources(request);
Assert.fail("Expected an exception going downgrade with no upgrade pack");
}
catch ( Exception e) {
}
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.0.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_test");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
requestProps.put(UpgradeResourceProvider.UPGRADE_FROM_VERSION,"2.1.1.0");
Map requestInfoProperties=new HashMap<>();
requestInfoProperties.put(UpgradeResourceDefinition.DOWNGRADE_DIRECTIVE,"true");
request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),requestInfoProperties);
RequestStatus status=upgradeResourceProvider.createResources(request);
assertEquals(1,status.getAssociatedResources().size());
Resource r=status.getAssociatedResources().iterator().next();
String id=r.getPropertyValue("Upgrade/request_id").toString();
UpgradeEntity entity=upgradeDao.findUpgrade(Long.parseLong(id));
assertNotNull(entity);
assertEquals("2.1.1",entity.getFromVersion());
assertEquals("2.2.0.0",entity.getToVersion());
assertEquals(Direction.DOWNGRADE,entity.getDirection());
StageDAO dao=injector.getInstance(StageDAO.class);
List stages=dao.findByRequestId(entity.getRequestId());
Gson gson=new Gson();
for ( StageEntity se : stages) {
Map map=gson.fromJson(se.getCommandParamsStage(),Map.class);
assertTrue(map.containsKey("upgrade_direction"));
assertEquals("downgrade",map.get("upgrade_direction"));
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","6.3");
host.setHostAttributes(hostAttributes);
host.persist();
clusters.mapHostToCluster("h2","c1");
Cluster cluster=clusters.getCluster("c1");
Service service=cluster.getService("ZOOKEEPER");
ServiceComponent component=service.getServiceComponent("ZOOKEEPER_SERVER");
ServiceComponentHost sch=component.addServiceComponentHost("h2");
sch.setVersion("2.2.2.2");
List upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(0,upgrades.size());
UpgradeEntity upgradeEntity=new UpgradeEntity();
upgradeEntity.setClusterId(cluster.getClusterId());
upgradeEntity.setDirection(Direction.UPGRADE);
upgradeEntity.setFromVersion("2.1.1.1");
upgradeEntity.setToVersion("2.2.2.2");
upgradeEntity.setUpgradePackage("upgrade_test");
upgradeEntity.setUpgradeType(UpgradeType.ROLLING);
upgradeEntity.setRequestId(1L);
upgradeDao.create(upgradeEntity);
upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(1,upgrades.size());
UpgradeEntity lastUpgrade=upgradeDao.findLastUpgradeForCluster(cluster.getClusterId());
assertNotNull(lastUpgrade);
Map requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.1.1.1");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_test");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
Map requestInfoProperties=new HashMap();
requestInfoProperties.put(UpgradeResourceDefinition.DOWNGRADE_DIRECTIVE,"true");
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),requestInfoProperties);
upgradeResourceProvider.createResources(request);
upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(2,upgrades.size());
UpgradeEntity downgrade=upgrades.get(1);
assertEquals(cluster.getClusterId(),downgrade.getClusterId().longValue());
List upgradeGroups=downgrade.getUpgradeGroups();
assertEquals(3,upgradeGroups.size());
UpgradeGroupEntity group=upgradeGroups.get(1);
assertEquals("ZOOKEEPER",group.getName());
assertEquals(4,group.getItems().size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.2.3");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_direction");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
upgradeResourceProvider.createResources(request);
List upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(1,upgrades.size());
UpgradeEntity upgrade=upgrades.get(0);
Long id=upgrade.getRequestId();
assertEquals(3,upgrade.getUpgradeGroups().size());
UpgradeGroupEntity group=upgrade.getUpgradeGroups().get(2);
Assert.assertEquals("POST_CLUSTER",group.getName());
Assert.assertTrue(!group.getItems().isEmpty());
for ( UpgradeItemEntity item : group.getItems()) {
Assert.assertFalse(item.getText().toLowerCase().contains("downgrade"));
}
requestProps.clear();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_direction");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
requestProps.put(UpgradeResourceProvider.UPGRADE_FROM_VERSION,"2.2.2.3");
Map requestInfoProps=new HashMap();
requestInfoProps.put("downgrade","true");
request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),requestInfoProps);
upgradeResourceProvider.createResources(request);
upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(2,upgrades.size());
upgrade=null;
for ( UpgradeEntity u : upgrades) {
if (!u.getRequestId().equals(id)) {
upgrade=u;
}
}
assertNotNull(upgrade);
assertEquals("Downgrade groups reduced from 3 to 2",2,upgrade.getUpgradeGroups().size());
group=upgrade.getUpgradeGroups().get(1);
assertEquals("Execution items increased from 1 to 2",2,group.getItems().size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.0.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_test");
requestProps.put(UpgradeResourceProvider.UPGRADE_TYPE,UpgradeType.ROLLING.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_FAILURES,Boolean.TRUE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_SC_FAILURES,Boolean.TRUE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_MANUAL_VERIFICATION,Boolean.FALSE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,Boolean.TRUE.toString());
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
upgradeResourceProvider.createResources(request);
List upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(1,upgrades.size());
UpgradeEntity entity=upgrades.get(0);
assertEquals(cluster.getClusterId(),entity.getClusterId().longValue());
List upgradeGroups=entity.getUpgradeGroups();
assertEquals(3,upgradeGroups.size());
UpgradeGroupEntity preClusterGroup=upgradeGroups.get(0);
assertEquals("PRE_CLUSTER",preClusterGroup.getName());
List preClusterUpgradeItems=preClusterGroup.getItems();
assertEquals(2,preClusterUpgradeItems.size());
assertEquals("Foo",preClusterUpgradeItems.get(0).getText());
assertEquals("Foo",preClusterUpgradeItems.get(1).getText());
UpgradeGroupEntity zookeeperGroup=upgradeGroups.get(1);
assertEquals("ZOOKEEPER",zookeeperGroup.getName());
List zookeeperUpgradeItems=zookeeperGroup.getItems();
assertEquals(5,zookeeperUpgradeItems.size());
assertEquals("This is a manual task with a placeholder of placeholder-rendered-properly",zookeeperUpgradeItems.get(0).getText());
assertEquals("Restarting ZooKeeper Server on h1",zookeeperUpgradeItems.get(1).getText());
assertEquals("Skipping Configuration Task 2.2.0",zookeeperUpgradeItems.get(2).getText());
assertEquals("Service Check ZooKeeper",zookeeperUpgradeItems.get(3).getText());
assertEquals("Verifying Skipped Failures",zookeeperUpgradeItems.get(4).getText());
UpgradeItemEntity skippedFailureCheck=zookeeperUpgradeItems.get(zookeeperUpgradeItems.size() - 1);
skippedFailureCheck.getTasks().contains(AutoSkipFailedSummaryAction.class.getName());
UpgradeGroupEntity postClusterGroup=upgradeGroups.get(2);
assertEquals("POST_CLUSTER",postClusterGroup.getName());
List postClusterUpgradeItems=postClusterGroup.getItems();
assertEquals(2,postClusterUpgradeItems.size());
assertEquals("Please confirm you are ready to finalize",postClusterUpgradeItems.get(0).getText());
assertEquals("Save Cluster State",postClusterUpgradeItems.get(1).getText());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier createdResources=status.getAssociatedResources();
assertEquals(1,createdResources.size());
Resource res=createdResources.iterator().next();
Long id=(Long)res.getPropertyValue("Upgrade/request_id");
assertNotNull(id);
assertEquals(Long.valueOf(1),id);
Map requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_REQUEST_ID,id.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_REQUEST_STATUS,"ABORTED");
UpgradeResourceProvider urp=createProvider(amc);
Request req=PropertyHelper.getUpdateRequest(requestProps,null);
urp.updateResources(req,null);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.0.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_test");
requestProps.put(UpgradeResourceProvider.UPGRADE_TYPE,UpgradeType.ROLLING.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_FAILURES,Boolean.TRUE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_SC_FAILURES,Boolean.TRUE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_MANUAL_VERIFICATION,Boolean.TRUE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,Boolean.TRUE.toString());
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
upgradeResourceProvider.createResources(request);
List upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(1,upgrades.size());
UpgradeEntity entity=upgrades.get(0);
assertEquals(cluster.getClusterId(),entity.getClusterId().longValue());
List upgradeGroups=entity.getUpgradeGroups();
assertEquals(2,upgradeGroups.size());
UpgradeGroupEntity zookeeperGroup=upgradeGroups.get(0);
assertEquals("ZOOKEEPER",zookeeperGroup.getName());
List zookeeperUpgradeItems=zookeeperGroup.getItems();
assertEquals(4,zookeeperUpgradeItems.size());
assertEquals("Restarting ZooKeeper Server on h1",zookeeperUpgradeItems.get(0).getText());
assertEquals("Skipping Configuration Task 2.2.0",zookeeperUpgradeItems.get(1).getText());
assertEquals("Service Check ZooKeeper",zookeeperUpgradeItems.get(2).getText());
assertEquals("Verifying Skipped Failures",zookeeperUpgradeItems.get(3).getText());
UpgradeItemEntity skippedFailureCheck=zookeeperUpgradeItems.get(zookeeperUpgradeItems.size() - 1);
skippedFailureCheck.getTasks().contains(AutoSkipFailedSummaryAction.class.getName());
UpgradeGroupEntity postClusterGroup=upgradeGroups.get(1);
assertEquals("POST_CLUSTER",postClusterGroup.getName());
List postClusterUpgradeItems=postClusterGroup.getItems();
assertEquals(1,postClusterUpgradeItems.size());
assertEquals("Save Cluster State",postClusterUpgradeItems.get(0).getText());
}
BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier upgrades=upgradeDao.findUpgrades(1);
assertEquals(1,upgrades.size());
UpgradeEntity entity=upgrades.get(0);
HostRoleCommandDAO dao=injector.getInstance(HostRoleCommandDAO.class);
List tasks=dao.findByRequest(entity.getRequestId());
for ( HostRoleCommandEntity task : tasks) {
StageEntity stage=task.getStage();
if (stage.isSkippable() && stage.isAutoSkipOnFailureSupported()) {
assertTrue(task.isFailureAutoSkipped());
}
else {
assertFalse(task.isFailureAutoSkipped());
}
}
Map requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.0.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_FAILURES,Boolean.TRUE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_SC_FAILURES,Boolean.FALSE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_REQUEST_ID,"" + entity.getRequestId());
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getUpdateRequest(requestProps,null);
upgradeResourceProvider.updateResources(request,null);
tasks=dao.findByRequest(entity.getRequestId());
for ( HostRoleCommandEntity task : tasks) {
if (task.getRoleCommand() == RoleCommand.SERVICE_CHECK) {
assertFalse(task.isFailureAutoSkipped());
}
else {
StageEntity stage=task.getStage();
if (stage.isSkippable() && stage.isAutoSkipOnFailureSupported()) {
assertTrue(task.isFailureAutoSkipped());
}
else {
assertFalse(task.isFailureAutoSkipped());
}
}
}
requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.0.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_FAILURES,Boolean.FALSE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_SC_FAILURES,Boolean.TRUE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_REQUEST_ID,"" + entity.getRequestId());
request=PropertyHelper.getUpdateRequest(requestProps,null);
upgradeResourceProvider.updateResources(request,null);
tasks=dao.findByRequest(entity.getRequestId());
for ( HostRoleCommandEntity task : tasks) {
if (task.getRoleCommand() == RoleCommand.SERVICE_CHECK) {
StageEntity stage=task.getStage();
if (stage.isSkippable() && stage.isAutoSkipOnFailureSupported()) {
assertTrue(task.isFailureAutoSkipped());
}
else {
assertFalse(task.isFailureAutoSkipped());
}
}
else {
assertFalse(task.isFailureAutoSkipped());
}
}
requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.0.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_FAILURES,Boolean.FALSE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_SC_FAILURES,Boolean.FALSE.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_REQUEST_ID,"" + entity.getRequestId());
request=PropertyHelper.getUpdateRequest(requestProps,null);
upgradeResourceProvider.updateResources(request,null);
tasks=dao.findByRequest(entity.getRequestId());
for ( HostRoleCommandEntity task : tasks) {
assertFalse(task.isFailureAutoSkipped());
}
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier createdResources=status.getAssociatedResources();
assertEquals(1,createdResources.size());
Resource res=createdResources.iterator().next();
Long id=(Long)res.getPropertyValue("Upgrade/request_id");
assertNotNull(id);
assertEquals(Long.valueOf(1),id);
Map requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_REQUEST_ID,id.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_REQUEST_STATUS,"ABORTED");
UpgradeResourceProvider urp=createProvider(amc);
Request req=PropertyHelper.getUpdateRequest(requestProps,null);
urp.updateResources(req,null);
ActionManager am=injector.getInstance(ActionManager.class);
List commands=am.getRequestTasks(id);
boolean foundOne=false;
for ( HostRoleCommand hrc : commands) {
if (hrc.getRole().equals(Role.AMBARI_SERVER_ACTION)) {
assertEquals(-1L,hrc.getHostId());
assertNull(hrc.getHostName());
foundOne=true;
}
}
assertTrue("Expected at least one server-side action",foundOne);
HostRoleCommand cmd=commands.get(commands.size() - 1);
HostRoleCommandDAO dao=injector.getInstance(HostRoleCommandDAO.class);
HostRoleCommandEntity entity=dao.findByPK(cmd.getTaskId());
entity.setStatus(HostRoleStatus.ABORTED);
dao.merge(entity);
requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_REQUEST_ID,id.toString());
requestProps.put(UpgradeResourceProvider.UPGRADE_REQUEST_STATUS,"PENDING");
req=PropertyHelper.getUpdateRequest(requestProps,null);
urp.updateResources(req,null);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier IgnoredMethod HybridVerifier (){
{
put("a","b");
}
}
);
config.setTag("abcdefg");
cluster.addConfig(config);
cluster.addDesiredConfig("admin",Collections.singleton(config));
Map requestProps=new HashMap();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.0.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_test_nonrolling");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
upgradeResourceProvider.createResources(request);
List upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(1,upgrades.size());
UpgradeEntity upgrade=upgrades.get(0);
assertEquals(5,upgrade.getUpgradeGroups().size());
UpgradeGroupEntity group=upgrade.getUpgradeGroups().get(2);
assertEquals(1,group.getItems().size());
group=upgrade.getUpgradeGroups().get(0);
assertEquals(1,group.getItems().size());
assertTrue(cluster.getDesiredConfigs().containsKey("zoo.cfg"));
StackId newStack=cluster.getDesiredStackVersion();
assertFalse(oldStack.equals(newStack));
for ( Service s : cluster.getServices().values()) {
assertEquals(newStack,s.getDesiredStackVersion());
for ( ServiceComponent sc : s.getServiceComponents().values()) {
assertEquals(newStack,sc.getDesiredStackVersion());
for ( ServiceComponentHost sch : sc.getServiceComponentHosts().values()) {
assertEquals(newStack,sch.getDesiredStackVersion());
}
}
}
}
APIUtilityVerifier BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier createdResources=status.getAssociatedResources();
assertEquals(1,createdResources.size());
Resource res=createdResources.iterator().next();
Long id=(Long)res.getPropertyValue("Upgrade/request_id");
assertNotNull(id);
assertEquals(Long.valueOf(1),id);
StageDAO stageDao=injector.getInstance(StageDAO.class);
HostRoleCommandDAO hrcDao=injector.getInstance(HostRoleCommandDAO.class);
List stages=stageDao.findByRequestId(id);
List tasks=hrcDao.findByRequest(id);
Set stageIds=new HashSet();
for ( StageEntity se : stages) {
stageIds.add(se.getStageId());
}
CalculatedStatus calc=null;
int i=0;
for ( HostRoleCommandEntity hrce : tasks) {
hrce.setStatus(HostRoleStatus.IN_PROGRESS);
hrcDao.merge(hrce);
calc=CalculatedStatus.statusFromStageSummary(hrcDao.findAggregateCounts(id),stageIds);
assertEquals(((i++) + 1) * 4.375d,calc.getPercent(),0.01d);
assertEquals(HostRoleStatus.IN_PROGRESS,calc.getStatus());
}
i=0;
for ( HostRoleCommandEntity hrce : tasks) {
hrce.setStatus(HostRoleStatus.COMPLETED);
hrcDao.merge(hrce);
calc=CalculatedStatus.statusFromStageSummary(hrcDao.findAggregateCounts(id),stageIds);
assertEquals(35 + (((i++) + 1) * 8.125),calc.getPercent(),0.01d);
if (i < 8) {
assertEquals(HostRoleStatus.IN_PROGRESS,calc.getStatus());
}
}
calc=CalculatedStatus.statusFromStageSummary(hrcDao.findAggregateCounts(id),stageIds);
assertEquals(HostRoleStatus.COMPLETED,calc.getStatus());
assertEquals(100d,calc.getPercent(),0.01d);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > stack211Configs=new HashMap>();
Map stack211FooType=new HashMap();
Map stack211BarType=new HashMap();
Map stack211BazType=new HashMap();
stack211Configs.put("foo-site",stack211FooType);
stack211Configs.put("bar-site",stack211BarType);
stack211Configs.put("baz-site",stack211BazType);
stack211FooType.put("1","one");
stack211FooType.put("11","one-one");
stack211BarType.put("2","two");
stack211BazType.put("3","three");
Map> stack220Configs=new HashMap>();
Map stack220FooType=new HashMap();
Map stack220BazType=new HashMap();
Map stack220FlumeEnvType=new HashMap();
stack220Configs.put("foo-site",stack220FooType);
stack220Configs.put("baz-site",stack220BazType);
stack220Configs.put("flume-env",stack220FlumeEnvType);
stack220FooType.put("1","one-new");
stack220FooType.put("111","one-one-one");
stack220BazType.put("3","three-new");
stack220FlumeEnvType.put("flume_env_key","flume-env-value");
Map clusterFooType=new HashMap();
Map clusterBarType=new HashMap();
Map clusterBazType=new HashMap();
Config fooConfig=EasyMock.createNiceMock(Config.class);
Config barConfig=EasyMock.createNiceMock(Config.class);
Config bazConfig=EasyMock.createNiceMock(Config.class);
clusterFooType.put("1","one");
clusterFooType.put("11","one-one");
clusterBarType.put("2","two");
clusterBazType.put("3","three-changed");
expect(fooConfig.getProperties()).andReturn(clusterFooType);
expect(barConfig.getProperties()).andReturn(clusterBarType);
expect(bazConfig.getProperties()).andReturn(clusterBazType);
Map desiredConfigurations=new HashMap();
desiredConfigurations.put("foo-site",null);
desiredConfigurations.put("bar-site",null);
desiredConfigurations.put("baz-site",null);
Cluster cluster=EasyMock.createNiceMock(Cluster.class);
expect(cluster.getCurrentStackVersion()).andReturn(stack211);
expect(cluster.getDesiredStackVersion()).andReturn(stack220);
expect(cluster.getDesiredConfigs()).andReturn(desiredConfigurations);
expect(cluster.getDesiredConfigByType("foo-site")).andReturn(fooConfig);
expect(cluster.getDesiredConfigByType("bar-site")).andReturn(barConfig);
expect(cluster.getDesiredConfigByType("baz-site")).andReturn(bazConfig);
EasyMock.reset(configHelper);
expect(configHelper.getDefaultProperties(EasyMock.eq(stack211),EasyMock.anyObject(Cluster.class))).andReturn(stack211Configs).anyTimes();
expect(configHelper.getDefaultProperties(EasyMock.eq(stack220),EasyMock.anyObject(Cluster.class))).andReturn(stack220Configs).anyTimes();
Capture>> expectedConfigurationsCapture=new Capture>>();
configHelper.createConfigTypes(EasyMock.anyObject(Cluster.class),EasyMock.anyObject(AmbariManagementController.class),EasyMock.capture(expectedConfigurationsCapture),EasyMock.anyObject(String.class),EasyMock.anyObject(String.class));
EasyMock.expectLastCall().once();
EasyMock.replay(configHelper,cluster,fooConfig,barConfig,bazConfig);
UpgradeResourceProvider upgradeResourceProvider=createProvider(amc);
Map upgradePacks=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
UpgradePack upgrade=upgradePacks.get("upgrade_to_new_stack");
upgradeResourceProvider.applyStackAndProcessConfigurations(stack211.getStackName(),cluster,"2.2.0.0",Direction.UPGRADE,upgrade,"admin");
Map> expectedConfigurations=expectedConfigurationsCapture.getValue();
Map expectedFooType=expectedConfigurations.get("foo-site");
Map expectedBarType=expectedConfigurations.get("bar-site");
Map expectedBazType=expectedConfigurations.get("baz-site");
assertFalse(expectedConfigurations.containsKey("flume-env"));
assertEquals("one-new",expectedFooType.get("1"));
assertEquals("one-one",expectedFooType.get("11"));
assertEquals("two",expectedBarType.get("2"));
assertEquals("three-changed",expectedBazType.get("3"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier requestProps=new HashMap<>();
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.2.0.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_nonrolling_new_stack");
requestProps.put(UpgradeResourceProvider.UPGRADE_TYPE,"NON_ROLLING");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
ResourceProvider upgradeResourceProvider=createProvider(amc);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
upgradeResourceProvider.createResources(request);
List upgrades=upgradeDao.findUpgrades(cluster.getClusterId());
assertEquals(1,upgrades.size());
List groups=upgrades.get(0).getUpgradeGroups();
boolean isHiveGroupFound=false;
boolean isZKGroupFound=false;
for ( UpgradeGroupEntity group : groups) {
if (group.getName().equalsIgnoreCase("hive")) {
isHiveGroupFound=true;
}
else if (group.getName().equalsIgnoreCase("zookeeper")) {
isZKGroupFound=true;
}
}
assertTrue(isHiveGroupFound);
assertTrue(isZKGroupFound);
isHiveGroupFound=false;
isZKGroupFound=false;
sch.setVersion("2.2.0.0");
StackId stackId=new StackId("HDP","2.2.0");
cluster.setDesiredStackVersion(stackId,true);
requestProps.put(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME,"c1");
requestProps.put(UpgradeResourceProvider.UPGRADE_VERSION,"2.1.1.0");
requestProps.put(UpgradeResourceProvider.UPGRADE_PACK,"upgrade_nonrolling_new_stack");
requestProps.put(UpgradeResourceProvider.UPGRADE_SKIP_PREREQUISITE_CHECKS,"true");
requestProps.put(UpgradeResourceProvider.UPGRADE_FROM_VERSION,"2.2.0.0");
Map requestInfoProperties=new HashMap<>();
requestInfoProperties.put(UpgradeResourceDefinition.DOWNGRADE_DIRECTIVE,"true");
request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),requestInfoProperties);
RequestStatus status=upgradeResourceProvider.createResources(request);
UpgradeEntity upgradeEntity=upgradeDao.findUpgradeByRequestId(getRequestId(status));
for ( UpgradeGroupEntity group : upgradeEntity.getUpgradeGroups()) {
if (group.getName().equalsIgnoreCase("hive")) {
isHiveGroupFound=true;
}
else if (group.getName().equalsIgnoreCase("zookeeper")) {
isZKGroupFound=true;
}
}
assertTrue(isHiveGroupFound);
assertFalse(isZKGroupFound);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier createdResources=status.getAssociatedResources();
assertEquals(1,createdResources.size());
Resource res=createdResources.iterator().next();
Long id=(Long)res.getPropertyValue("Upgrade/request_id");
assertNotNull(id);
assertEquals(Long.valueOf(1),id);
Set propertyIds=new HashSet();
propertyIds.add("Upgrade");
Predicate predicate=new PredicateBuilder().property(UpgradeResourceProvider.UPGRADE_REQUEST_ID).equals("1").and().property(UpgradeResourceProvider.UPGRADE_CLUSTER_NAME).equals("c1").toPredicate();
Request request=PropertyHelper.getReadRequest(propertyIds);
ResourceProvider upgradeResourceProvider=createProvider(amc);
Set resources=upgradeResourceProvider.getResources(request,predicate);
assertEquals(1,resources.size());
res=resources.iterator().next();
assertNotNull(res.getPropertyValue("Upgrade/progress_percent"));
assertNotNull(res.getPropertyValue(UpgradeResourceProvider.UPGRADE_DIRECTION));
assertEquals(Direction.UPGRADE,res.getPropertyValue(UpgradeResourceProvider.UPGRADE_DIRECTION));
assertEquals(false,res.getPropertyValue(UpgradeResourceProvider.UPGRADE_SKIP_FAILURES));
assertEquals(false,res.getPropertyValue(UpgradeResourceProvider.UPGRADE_SKIP_SC_FAILURES));
assertEquals(UpgradeType.ROLLING,res.getPropertyValue(UpgradeResourceProvider.UPGRADE_TYPE));
propertyIds.clear();
propertyIds.add("UpgradeGroup");
predicate=new PredicateBuilder().property(UpgradeGroupResourceProvider.UPGRADE_REQUEST_ID).equals("1").and().property(UpgradeGroupResourceProvider.UPGRADE_CLUSTER_NAME).equals("c1").toPredicate();
request=PropertyHelper.getReadRequest(propertyIds);
ResourceProvider upgradeGroupResourceProvider=new UpgradeGroupResourceProvider(amc);
resources=upgradeGroupResourceProvider.getResources(request,predicate);
assertEquals(3,resources.size());
res=resources.iterator().next();
assertNotNull(res.getPropertyValue("UpgradeGroup/status"));
assertNotNull(res.getPropertyValue("UpgradeGroup/group_id"));
assertNotNull(res.getPropertyValue("UpgradeGroup/total_task_count"));
assertNotNull(res.getPropertyValue("UpgradeGroup/in_progress_task_count"));
assertNotNull(res.getPropertyValue("UpgradeGroup/completed_task_count"));
propertyIds.clear();
propertyIds.add("UpgradeItem");
predicate=new PredicateBuilder().property(UpgradeItemResourceProvider.UPGRADE_GROUP_ID).equals("1").and().property(UpgradeItemResourceProvider.UPGRADE_REQUEST_ID).equals("1").and().property(UpgradeItemResourceProvider.UPGRADE_CLUSTER_NAME).equals("c1").toPredicate();
request=PropertyHelper.getReadRequest(propertyIds);
ResourceProvider upgradeItemResourceProvider=new UpgradeItemResourceProvider(amc);
resources=upgradeItemResourceProvider.getResources(request,predicate);
assertEquals(2,resources.size());
res=resources.iterator().next();
assertNotNull(res.getPropertyValue("UpgradeItem/status"));
propertyIds.clear();
propertyIds.add("UpgradeItem");
predicate=new PredicateBuilder().property(UpgradeItemResourceProvider.UPGRADE_GROUP_ID).equals("3").and().property(UpgradeItemResourceProvider.UPGRADE_REQUEST_ID).equals("1").and().property(UpgradeItemResourceProvider.UPGRADE_CLUSTER_NAME).equals("c1").toPredicate();
request=PropertyHelper.getReadRequest(propertyIds);
upgradeItemResourceProvider=new UpgradeItemResourceProvider(amc);
resources=upgradeItemResourceProvider.getResources(request,predicate);
assertEquals(2,resources.size());
res=resources.iterator().next();
assertEquals("Confirm Finalize",res.getPropertyValue("UpgradeItem/context"));
assertTrue(res.getPropertyValue("UpgradeItem/text").toString().startsWith("Please confirm"));
}
Class: org.apache.ambari.server.controller.internal.UserPrivilegeResourceProviderTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.internal.ValidationResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier keyPropertyIds=Collections.emptyMap();
Set propertyIds=Collections.singleton(ValidationResourceProvider.VALIDATION_ID_PROPERTY_ID);
AmbariManagementController ambariManagementController=mock(AmbariManagementController.class);
ValidationResourceProvider provider=spy(new ValidationResourceProvider(propertyIds,keyPropertyIds,ambariManagementController));
StackAdvisorRequest stackAdvisorRequest=mock(StackAdvisorRequest.class);
Request request=mock(Request.class);
doReturn(stackAdvisorRequest).when(provider).prepareStackAdvisorRequest(request);
StackAdvisorHelper saHelper=mock(StackAdvisorHelper.class);
ValidationResponse response=mock(ValidationResponse.class);
Version version=mock(Version.class);
doReturn(3).when(response).getId();
doReturn(version).when(response).getVersion();
doReturn(response).when(saHelper).validate(any(StackAdvisorRequest.class));
ValidationResourceProvider.init(saHelper);
RequestStatus status=provider.createResources(request);
Set associatedResources=status.getAssociatedResources();
assertNotNull(associatedResources);
assertEquals(1,associatedResources.size());
Resource resource=associatedResources.iterator().next();
Object requestId=resource.getPropertyValue(ValidationResourceProvider.VALIDATION_ID_PROPERTY_ID);
assertNotNull(requestId);
assertEquals(3,requestId);
}
Class: org.apache.ambari.server.controller.internal.ViewInstanceResourceProviderTest InternalCallVerifier NullVerifier > properties=new HashSet>();
Map propertyMap=new HashMap();
propertyMap.put(ViewInstanceResourceProvider.ICON_PATH_ID,"path");
properties.add(propertyMap);
PredicateBuilder predicateBuilder=new PredicateBuilder();
Predicate predicate=predicateBuilder.property(ViewInstanceResourceProvider.VIEW_NAME_PROPERTY_ID).equals("V1").toPredicate();
ViewEntity viewEntity=new ViewEntity();
viewEntity.setName("V1{1.0.0}");
viewEntity.setStatus(ViewDefinition.ViewStatus.DEPLOYING);
ViewInstanceEntity viewInstanceEntity=new ViewInstanceEntity();
viewInstanceEntity.setViewName("V1{1.0.0}");
viewInstanceEntity.setName("I1");
viewInstanceEntity.setViewEntity(viewEntity);
expect(singleton.getDefinitions()).andReturn(Collections.singleton(viewEntity));
replay(singleton);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator());
provider.updateResources(PropertyHelper.getCreateRequest(properties,null),predicate);
Assert.assertNull(viewInstanceEntity.getIcon());
verify(singleton);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier propertyIds=new HashSet();
propertyIds.add(ViewInstanceResourceProvider.PROPERTIES_PROPERTY_ID);
propertyIds.add(ViewInstanceResourceProvider.CLUSTER_HANDLE_PROPERTY_ID);
ViewInstanceEntity viewInstanceEntity=createNiceMock(ViewInstanceEntity.class);
ViewEntity viewEntity=createNiceMock(ViewEntity.class);
expect(viewInstanceEntity.getViewEntity()).andReturn(viewEntity).anyTimes();
Map propertyMap=new HashMap();
propertyMap.put("par1","val1");
propertyMap.put("par2","val2");
expect(viewInstanceEntity.getPropertyMap()).andReturn(propertyMap);
expect(viewInstanceEntity.getData()).andReturn(Collections.emptyList()).anyTimes();
expect(singleton.checkAdmin()).andReturn(true);
expect(singleton.checkAdmin()).andReturn(false);
expect(viewInstanceEntity.getClusterHandle()).andReturn("c1");
replay(singleton,viewEntity,viewInstanceEntity);
Resource resource=provider.toResource(viewInstanceEntity,propertyIds);
Map> properties=resource.getPropertiesMap();
assertEquals(2,properties.size());
Map props=properties.get("ViewInstanceInfo");
assertNotNull(props);
assertEquals(1,props.size());
assertEquals("c1",props.get("cluster_handle"));
props=properties.get("ViewInstanceInfo/properties");
assertNotNull(props);
assertEquals(2,props.size());
assertEquals("val1",props.get("par1"));
assertEquals("val2",props.get("par2"));
resource=provider.toResource(viewInstanceEntity,propertyIds);
properties=resource.getPropertiesMap();
props=properties.get("ViewInstanceInfo/properties");
assertNull(props);
verify(singleton,viewEntity,viewInstanceEntity);
}
Class: org.apache.ambari.server.controller.internal.ViewPermissionResourceProviderTest InternalCallVerifier EqualityVerifier permissionEntities=new LinkedList();
PermissionEntity permissionEntity=createNiceMock(PermissionEntity.class);
PermissionEntity viewUsePermissionEntity=createNiceMock(PermissionEntity.class);
ResourceTypeEntity resourceTypeEntity=createNiceMock(ResourceTypeEntity.class);
ViewEntity viewEntity=createMock(ViewEntity.class);
permissionEntities.add(permissionEntity);
expect(dao.findViewUsePermission()).andReturn(viewUsePermissionEntity);
expect(dao.findAll()).andReturn(Collections.singletonList(permissionEntity));
expect(permissionEntity.getResourceType()).andReturn(resourceTypeEntity);
expect(viewEntity.isDeployed()).andReturn(false).anyTimes();
expect(viewRegistry.getDefinition(resourceTypeEntity)).andReturn(viewEntity);
replay(dao,permissionEntity,viewUsePermissionEntity,resourceTypeEntity,viewEntity,viewRegistry);
ViewPermissionResourceProvider provider=new ViewPermissionResourceProvider();
Set resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(0,resources.size());
verify(dao,permissionEntity,viewUsePermissionEntity,resourceTypeEntity,viewEntity,viewRegistry);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier permissionEntities=new LinkedList();
PermissionEntity permissionEntity=createNiceMock(PermissionEntity.class);
PermissionEntity viewUsePermissionEntity=createNiceMock(PermissionEntity.class);
ResourceTypeEntity resourceTypeEntity=createNiceMock(ResourceTypeEntity.class);
ViewEntity viewEntity=createMock(ViewEntity.class);
permissionEntities.add(permissionEntity);
expect(dao.findViewUsePermission()).andReturn(viewUsePermissionEntity);
expect(dao.findAll()).andReturn(Collections.singletonList(permissionEntity));
expect(permissionEntity.getId()).andReturn(99);
expect(permissionEntity.getPermissionName()).andReturn("P1");
expect(permissionEntity.getResourceType()).andReturn(resourceTypeEntity);
expect(resourceTypeEntity.getName()).andReturn("V1");
expect(viewEntity.isDeployed()).andReturn(true).anyTimes();
expect(viewEntity.getCommonName()).andReturn("V1").anyTimes();
expect(viewEntity.getVersion()).andReturn("1.0.0").anyTimes();
expect(viewRegistry.getDefinition(resourceTypeEntity)).andReturn(viewEntity);
replay(dao,permissionEntity,viewUsePermissionEntity,resourceTypeEntity,viewEntity,viewRegistry);
ViewPermissionResourceProvider provider=new ViewPermissionResourceProvider();
Set resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals(99,resource.getPropertyValue(PermissionResourceProvider.PERMISSION_ID_PROPERTY_ID));
Assert.assertEquals("P1",resource.getPropertyValue(PermissionResourceProvider.PERMISSION_NAME_PROPERTY_ID));
Assert.assertEquals("V1",resource.getPropertyValue(PermissionResourceProvider.RESOURCE_NAME_PROPERTY_ID));
verify(dao,permissionEntity,viewUsePermissionEntity,resourceTypeEntity,viewEntity,viewRegistry);
}
Class: org.apache.ambari.server.controller.internal.ViewPrivilegeResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier privilegeEntities=new LinkedList();
PrivilegeEntity privilegeEntity=createNiceMock(PrivilegeEntity.class);
ResourceEntity resourceEntity=createNiceMock(ResourceEntity.class);
UserEntity userEntity=createNiceMock(UserEntity.class);
PrincipalEntity principalEntity=createNiceMock(PrincipalEntity.class);
PrincipalTypeEntity principalTypeEntity=createNiceMock(PrincipalTypeEntity.class);
PermissionEntity permissionEntity=createNiceMock(PermissionEntity.class);
List principalEntities=new LinkedList();
principalEntities.add(principalEntity);
List userEntities=new LinkedList();
userEntities.add(userEntity);
privilegeEntities.add(privilegeEntity);
expect(privilegeDAO.findAll()).andReturn(privilegeEntities);
expect(privilegeEntity.getResource()).andReturn(resourceEntity).anyTimes();
expect(privilegeEntity.getPrincipal()).andReturn(principalEntity).anyTimes();
expect(privilegeEntity.getPermission()).andReturn(permissionEntity).anyTimes();
expect(resourceEntity.getId()).andReturn(20L).anyTimes();
expect(principalEntity.getId()).andReturn(20L).anyTimes();
expect(userEntity.getPrincipal()).andReturn(principalEntity).anyTimes();
expect(userEntity.getUserName()).andReturn("joe").anyTimes();
expect(permissionEntity.getPermissionName()).andReturn("VIEW.USER").anyTimes();
expect(permissionEntity.getPermissionLabel()).andReturn("View User").anyTimes();
expect(principalEntity.getPrincipalType()).andReturn(principalTypeEntity).anyTimes();
expect(principalTypeEntity.getName()).andReturn("USER").anyTimes();
expect(permissionDAO.findById(PermissionEntity.VIEW_USER_PERMISSION)).andReturn(permissionEntity);
expect(userDAO.findUsersByPrincipal(principalEntities)).andReturn(userEntities);
expect(groupDAO.findGroupsByPrincipal(principalEntities)).andReturn(Collections.emptyList());
replay(privilegeDAO,userDAO,groupDAO,principalDAO,permissionDAO,resourceDAO,privilegeEntity,resourceEntity,userEntity,principalEntity,permissionEntity,principalTypeEntity);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createAdministrator("admin"));
PrivilegeResourceProvider provider=new ViewPrivilegeResourceProvider();
Set resources=provider.getResources(PropertyHelper.getReadRequest(),null);
Assert.assertEquals(1,resources.size());
Resource resource=resources.iterator().next();
Assert.assertEquals("VIEW.USER",resource.getPropertyValue(AmbariPrivilegeResourceProvider.PERMISSION_NAME_PROPERTY_ID));
Assert.assertEquals("View User",resource.getPropertyValue(AmbariPrivilegeResourceProvider.PERMISSION_LABEL_PROPERTY_ID));
Assert.assertEquals("joe",resource.getPropertyValue(AmbariPrivilegeResourceProvider.PRINCIPAL_NAME_PROPERTY_ID));
Assert.assertEquals("USER",resource.getPropertyValue(AmbariPrivilegeResourceProvider.PRINCIPAL_TYPE_PROPERTY_ID));
verify(privilegeDAO,userDAO,groupDAO,principalDAO,permissionDAO,resourceDAO,privilegeEntity,resourceEntity,userEntity,principalEntity,permissionEntity,principalTypeEntity);
}
Class: org.apache.ambari.server.controller.internal.WidgetLayoutResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier results=provider.getResources(request,predicate);
assertEquals(1,results.size());
Resource r=results.iterator().next();
Assert.assertEquals("section0",r.getPropertyValue(WidgetLayoutResourceProvider.WIDGETLAYOUT_SECTION_NAME_PROPERTY_ID));
Assert.assertEquals("CLUSTER",r.getPropertyValue(WidgetLayoutResourceProvider.WIDGETLAYOUT_SCOPE_PROPERTY_ID));
Assert.assertEquals("username",r.getPropertyValue(WidgetLayoutResourceProvider.WIDGETLAYOUT_USERNAME_PROPERTY_ID));
Assert.assertEquals("displ_name",r.getPropertyValue(WidgetLayoutResourceProvider.WIDGETLAYOUT_DISPLAY_NAME_PROPERTY_ID));
Assert.assertEquals("layout name0",r.getPropertyValue(WidgetLayoutResourceProvider.WIDGETLAYOUT_LAYOUT_NAME_PROPERTY_ID));
Assert.assertEquals("[]",r.getPropertyValue(WidgetLayoutResourceProvider.WIDGETLAYOUT_WIDGETS_PROPERTY_ID).toString());
}
InternalCallVerifier EqualityVerifier results=provider.getResources(request,null);
assertEquals(0,results.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier entityCapture=new Capture();
dao.create(capture(entityCapture));
expectLastCall();
WidgetEntity widgetEntity=new WidgetEntity();
widgetEntity.setId(1l);
widgetEntity.setListWidgetLayoutUserWidgetEntity(new ArrayList());
expect(widgetDAO.findById(anyLong())).andReturn(widgetEntity).anyTimes();
replay(amc,clusters,cluster,dao,widgetDAO);
WidgetLayoutResourceProvider provider=createProvider(amc);
Map requestProps=new HashMap();
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_CLUSTER_NAME_PROPERTY_ID,"c1");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_LAYOUT_NAME_PROPERTY_ID,"layout_name");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_DISPLAY_NAME_PROPERTY_ID,"display_name");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_SECTION_NAME_PROPERTY_ID,"section_name");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_USERNAME_PROPERTY_ID,"admin");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_SCOPE_PROPERTY_ID,"CLUSTER");
Set widgetsInfo=new LinkedHashSet();
Map widget=new HashMap();
widget.put("id","1");
widgetsInfo.add(widget);
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_WIDGETS_PROPERTY_ID,widgetsInfo);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
RequestStatus requestStatus=provider.createResources(request);
Assert.assertTrue(entityCapture.hasCaptured());
WidgetLayoutEntity entity=entityCapture.getValue();
Assert.assertNotNull(entity);
Assert.assertEquals(1,requestStatus.getAssociatedResources().size());
Assert.assertEquals(Long.valueOf(1),entity.getClusterId());
Assert.assertEquals("CLUSTER",entity.getScope());
Assert.assertEquals("layout_name",entity.getLayoutName());
Assert.assertEquals("display_name",entity.getDisplayName());
Assert.assertEquals("section_name",entity.getSectionName());
Assert.assertEquals("admin",entity.getUserName());
Assert.assertNotNull(entity.getListWidgetLayoutUserWidgetEntity());
Assert.assertNotNull(entity.getListWidgetLayoutUserWidgetEntity().get(0));
Assert.assertNotNull(entity.getListWidgetLayoutUserWidgetEntity().get(0).getWidget().getListWidgetLayoutUserWidgetEntity());
verify(amc,clusters,cluster,dao,widgetDAO);
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier entityCapture=new Capture();
dao.create(capture(entityCapture));
expectLastCall();
WidgetEntity widgetEntity=new WidgetEntity();
widgetEntity.setId(1L);
widgetEntity.setListWidgetLayoutUserWidgetEntity(new ArrayList());
WidgetEntity widgetEntity2=new WidgetEntity();
widgetEntity2.setId(2L);
widgetEntity2.setListWidgetLayoutUserWidgetEntity(new ArrayList());
expect(widgetDAO.findById(1L)).andReturn(widgetEntity).atLeastOnce();
replay(amc,clusters,cluster,dao,widgetDAO);
Map requestProps=new HashMap();
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_CLUSTER_NAME_PROPERTY_ID,"c1");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_LAYOUT_NAME_PROPERTY_ID,"layout_name");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_DISPLAY_NAME_PROPERTY_ID,"display_name");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_SECTION_NAME_PROPERTY_ID,"section_name");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_USERNAME_PROPERTY_ID,"admin");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_SCOPE_PROPERTY_ID,"CLUSTER");
Set widgetsInfo=new LinkedHashSet();
Map widget=new HashMap();
widget.put("id","1");
widgetsInfo.add(widget);
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_WIDGETS_PROPERTY_ID,widgetsInfo);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
WidgetLayoutResourceProvider provider=createProvider(amc);
provider.createResources(request);
Assert.assertTrue(entityCapture.hasCaptured());
WidgetLayoutEntity entity=entityCapture.getValue();
Assert.assertNotNull(entity);
Predicate predicate=new PredicateBuilder().property(WidgetLayoutResourceProvider.WIDGETLAYOUT_CLUSTER_NAME_PROPERTY_ID).equals("c1").and().property(WidgetLayoutResourceProvider.WIDGETLAYOUT_ID_PROPERTY_ID).equals("1").and().property(WidgetLayoutResourceProvider.WIDGETLAYOUT_USERNAME_PROPERTY_ID).equals("username").toPredicate();
entity.setId(Long.valueOf(1));
String oldLayoutName=entity.getLayoutName();
String oldScope=entity.getScope();
resetToStrict(dao,widgetDAO);
expect(dao.findById(1L)).andReturn(entity).anyTimes();
expect(dao.mergeWithFlush((WidgetLayoutEntity)anyObject())).andReturn(entity).anyTimes();
expect(widgetDAO.merge(widgetEntity)).andReturn(widgetEntity).anyTimes();
expect(widgetDAO.findById(2L)).andReturn(widgetEntity2).anyTimes();
replay(dao,widgetDAO);
requestProps=new HashMap();
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_LAYOUT_NAME_PROPERTY_ID,"layout_name_new");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_SCOPE_PROPERTY_ID,"USER");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_ID_PROPERTY_ID,"1");
widget.put("id","2");
widgetsInfo.add(widget);
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_WIDGETS_PROPERTY_ID,widgetsInfo);
request=PropertyHelper.getUpdateRequest(requestProps,null);
provider.updateResources(request,predicate);
Assert.assertFalse(oldLayoutName.equals(entity.getLayoutName()));
Assert.assertFalse(oldScope.equals(entity.getScope()));
verify(amc,clusters,cluster,dao,widgetDAO);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier entityCapture=new Capture();
dao.create(capture(entityCapture));
expectLastCall();
replay(amc,clusters,cluster,dao);
WidgetLayoutResourceProvider provider=createProvider(amc);
Map requestProps=new HashMap();
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_CLUSTER_NAME_PROPERTY_ID,"c1");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_LAYOUT_NAME_PROPERTY_ID,"layout_name");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_DISPLAY_NAME_PROPERTY_ID,"display_name");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_SECTION_NAME_PROPERTY_ID,"section_name");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_USERNAME_PROPERTY_ID,"admin");
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_SCOPE_PROPERTY_ID,"CLUSTER");
Set widgetsInfo=new LinkedHashSet();
requestProps.put(WidgetLayoutResourceProvider.WIDGETLAYOUT_WIDGETS_PROPERTY_ID,widgetsInfo);
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
provider.createResources(request);
Assert.assertTrue(entityCapture.hasCaptured());
WidgetLayoutEntity entity=entityCapture.getValue();
Assert.assertNotNull(entity);
Predicate predicate=new PredicateBuilder().property(WidgetLayoutResourceProvider.WIDGETLAYOUT_CLUSTER_NAME_PROPERTY_ID).equals("c1").and().property(WidgetLayoutResourceProvider.WIDGETLAYOUT_ID_PROPERTY_ID).equals("1").and().property(WidgetLayoutResourceProvider.WIDGETLAYOUT_USERNAME_PROPERTY_ID).equals("username").toPredicate();
entity.setId(Long.valueOf(1));
resetToStrict(dao);
expect(dao.findById(1L)).andReturn(entity).anyTimes();
dao.remove(capture(entityCapture));
expectLastCall();
replay(dao);
provider.deleteResources(predicate);
WidgetLayoutEntity entity1=entityCapture.getValue();
Assert.assertEquals(Long.valueOf(1),entity1.getId());
verify(amc,clusters,cluster,dao);
}
Class: org.apache.ambari.server.controller.internal.WidgetResourceProviderTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier entityCapture=new Capture();
dao.create(capture(entityCapture));
expectLastCall();
replay(amc,clusters,cluster,dao);
Map requestProps=new HashMap();
requestProps.put(WidgetResourceProvider.WIDGET_CLUSTER_NAME_PROPERTY_ID,"c1");
requestProps.put(WidgetResourceProvider.WIDGET_WIDGET_NAME_PROPERTY_ID,"widget name");
requestProps.put(WidgetResourceProvider.WIDGET_WIDGET_TYPE_PROPERTY_ID,"GAUGE");
requestProps.put(WidgetResourceProvider.WIDGET_AUTHOR_PROPERTY_ID,"admin");
requestProps.put(WidgetResourceProvider.WIDGET_SCOPE_PROPERTY_ID,"USER");
Set testSet=new LinkedHashSet();
HashMap testMap=new HashMap();
testMap.put("name","value");
testMap.put("name2","value2");
testSet.add(testMap);
requestProps.put(WidgetResourceProvider.WIDGET_METRICS_PROPERTY_ID,testSet);
requestProps.put(WidgetResourceProvider.WIDGET_VALUES_PROPERTY_ID,testSet);
requestProps.put(WidgetResourceProvider.WIDGET_PROPERTIES_PROPERTY_ID + "/property1","value1");
requestProps.put(WidgetResourceProvider.WIDGET_PROPERTIES_PROPERTY_ID + "/property2","value2");
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
WidgetResourceProvider provider=createProvider(amc);
provider.createResources(request);
Assert.assertTrue(entityCapture.hasCaptured());
WidgetEntity entity=entityCapture.getValue();
Assert.assertNotNull(entity);
Predicate predicate=new PredicateBuilder().property(WidgetResourceProvider.WIDGET_CLUSTER_NAME_PROPERTY_ID).equals("c1").and().property(WidgetResourceProvider.WIDGET_ID_PROPERTY_ID).equals("1").and().property(WidgetResourceProvider.WIDGET_AUTHOR_PROPERTY_ID).equals("username").toPredicate();
entity.setId(Long.valueOf(1));
String oldMetrics=entity.getMetrics();
String oldProperties=entity.getProperties();
String oldName=entity.getWidgetName();
resetToStrict(dao);
expect(dao.findById(1L)).andReturn(entity).anyTimes();
expect(dao.merge((WidgetEntity)anyObject())).andReturn(entity).anyTimes();
replay(dao);
requestProps=new HashMap();
requestProps.put(WidgetResourceProvider.WIDGET_ID_PROPERTY_ID,"1");
requestProps.put(WidgetResourceProvider.WIDGET_CLUSTER_NAME_PROPERTY_ID,"c1");
requestProps.put(WidgetResourceProvider.WIDGET_WIDGET_NAME_PROPERTY_ID,"widget name2");
requestProps.put(WidgetResourceProvider.WIDGET_WIDGET_TYPE_PROPERTY_ID,"GAUGE");
requestProps.put(WidgetResourceProvider.WIDGET_AUTHOR_PROPERTY_ID,"admin");
requestProps.put(WidgetResourceProvider.WIDGET_SCOPE_PROPERTY_ID,"USER");
testSet=new LinkedHashSet();
testMap=new HashMap();
testMap.put("name","new_value");
testMap.put("new_name","new_value2");
testSet.add(testMap);
requestProps.put(WidgetResourceProvider.WIDGET_METRICS_PROPERTY_ID,testSet);
requestProps.put(WidgetResourceProvider.WIDGET_VALUES_PROPERTY_ID,testSet);
requestProps.put(WidgetResourceProvider.WIDGET_PROPERTIES_PROPERTY_ID + "/property1","new_value1");
requestProps.put(WidgetResourceProvider.WIDGET_PROPERTIES_PROPERTY_ID + "/new_property","new_value2");
request=PropertyHelper.getUpdateRequest(requestProps,null);
provider.updateResources(request,predicate);
Assert.assertFalse(oldName.equals(entity.getWidgetName()));
Assert.assertFalse(oldMetrics.equals(entity.getMetrics()));
Assert.assertFalse(oldProperties.equals(entity.getProperties()));
Assert.assertEquals("[{\"name\":\"new_value\",\"new_name\":\"new_value2\"}]",entity.getMetrics());
Assert.assertTrue(CollectionPresentationUtils.isJsonsEquals("{\"new_property\":\"new_value2\",\"property1\":\"new_value1\"}",entity.getProperties()));
Assert.assertEquals("widget name2",entity.getWidgetName());
Assert.assertEquals(null,entity.getDefaultSectionName());
verify(amc,clusters,cluster,dao);
}
InternalCallVerifier EqualityVerifier results=provider.getResources(request,null);
assertEquals(0,results.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier entityCapture=new Capture();
dao.create(capture(entityCapture));
expectLastCall();
replay(amc,clusters,cluster,dao);
WidgetResourceProvider provider=createProvider(amc);
Map requestProps=new HashMap();
requestProps.put(WidgetResourceProvider.WIDGET_CLUSTER_NAME_PROPERTY_ID,"c1");
requestProps.put(WidgetResourceProvider.WIDGET_WIDGET_NAME_PROPERTY_ID,"widget name");
requestProps.put(WidgetResourceProvider.WIDGET_WIDGET_TYPE_PROPERTY_ID,"GAUGE");
requestProps.put(WidgetResourceProvider.WIDGET_AUTHOR_PROPERTY_ID,"admin");
requestProps.put(WidgetResourceProvider.WIDGET_SCOPE_PROPERTY_ID,"USER");
Set testSet=new LinkedHashSet();
HashMap testMap=new HashMap();
testMap.put("name","value");
testMap.put("name2","value2");
testSet.add(testMap);
requestProps.put(WidgetResourceProvider.WIDGET_METRICS_PROPERTY_ID,testSet);
requestProps.put(WidgetResourceProvider.WIDGET_VALUES_PROPERTY_ID,testSet);
requestProps.put(WidgetResourceProvider.WIDGET_PROPERTIES_PROPERTY_ID + "/property1","value1");
requestProps.put(WidgetResourceProvider.WIDGET_PROPERTIES_PROPERTY_ID + "/property2","value2");
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
provider.createResources(request);
Assert.assertTrue(entityCapture.hasCaptured());
WidgetEntity entity=entityCapture.getValue();
Assert.assertNotNull(entity);
Predicate predicate=new PredicateBuilder().property(WidgetResourceProvider.WIDGET_CLUSTER_NAME_PROPERTY_ID).equals("c1").and().property(WidgetResourceProvider.WIDGET_ID_PROPERTY_ID).equals("1").and().property(WidgetResourceProvider.WIDGET_AUTHOR_PROPERTY_ID).equals("username").toPredicate();
entity.setId(Long.valueOf(1));
resetToStrict(dao);
expect(dao.findById(1L)).andReturn(entity).anyTimes();
dao.remove(capture(entityCapture));
expectLastCall();
replay(dao);
provider.deleteResources(predicate);
WidgetEntity entity1=entityCapture.getValue();
Assert.assertEquals(Long.valueOf(1),entity1.getId());
verify(amc,clusters,cluster,dao);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier results=provider.getResources(request,predicate);
assertEquals(1,results.size());
Resource r=results.iterator().next();
Assert.assertEquals("GAUGE",r.getPropertyValue(WidgetResourceProvider.WIDGET_WIDGET_TYPE_PROPERTY_ID));
Assert.assertEquals("CLUSTER",r.getPropertyValue(WidgetResourceProvider.WIDGET_SCOPE_PROPERTY_ID));
Assert.assertEquals("username",r.getPropertyValue(WidgetResourceProvider.WIDGET_AUTHOR_PROPERTY_ID));
Assert.assertEquals("widget name",r.getPropertyValue(WidgetResourceProvider.WIDGET_WIDGET_NAME_PROPERTY_ID));
Object metrics=r.getPropertyValue(WidgetResourceProvider.WIDGET_METRICS_PROPERTY_ID);
Assert.assertEquals("[{\"widget_id\":\"metrics/jvm/HeapMemoryUsed\"," + "\"host_component_criteria\":\"host_components/metrics/dfs/FSNamesystem/HAState\\u003dactive\"," + "\"service_name\":\"HDFS\",\"component_name\":\"NAMENODE\","+ "\"name\":\"java.lang:type\\u003dMemory.HeapMemoryUsage[used]\",\"category\":\"\"},"+ "{\"widget_id\":\"metrics/jvm/HeapMemoryMax\","+ "\"host_component_criteria\":\"host_components/metrics/dfs/FSNamesystem/HAState\\u003dactive\","+ "\"service_name\":\"HDFS\",\"component_name\":\"NAMENODE\","+ "\"name\":\"java.lang:type\\u003dMemory.HeapMemoryUsage[max]\","+ "\"category\":\"\"}]",r.getPropertyValue(WidgetResourceProvider.WIDGET_METRICS_PROPERTY_ID));
Assert.assertEquals("[{\"name\":\"NameNode Heap\"," + "\"value\":\"${java.lang:type\\u003dMemory.HeapMemoryUsage[used] / " + "java.lang:type\\u003dMemory.HeapMemoryUsage[max]}\"}]",r.getPropertyValue(WidgetResourceProvider.WIDGET_VALUES_PROPERTY_ID));
Assert.assertEquals("{\"name\":\"value\"}",r.getPropertyValue(WidgetResourceProvider.WIDGET_PROPERTIES_PROPERTY_ID));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier entityCapture=new Capture();
dao.create(capture(entityCapture));
expectLastCall();
replay(amc,clusters,cluster,dao);
WidgetResourceProvider provider=createProvider(amc);
Map requestProps=new HashMap();
requestProps.put(WidgetResourceProvider.WIDGET_CLUSTER_NAME_PROPERTY_ID,"c1");
requestProps.put(WidgetResourceProvider.WIDGET_WIDGET_NAME_PROPERTY_ID,"widget name");
requestProps.put(WidgetResourceProvider.WIDGET_WIDGET_TYPE_PROPERTY_ID,"GAUGE");
requestProps.put(WidgetResourceProvider.WIDGET_AUTHOR_PROPERTY_ID,"admin");
requestProps.put(WidgetResourceProvider.WIDGET_SCOPE_PROPERTY_ID,"USER");
Set testSet=new LinkedHashSet();
HashMap testMap=new HashMap();
testMap.put("name","value");
testMap.put("name2","value2");
testSet.add(testMap);
requestProps.put(WidgetResourceProvider.WIDGET_METRICS_PROPERTY_ID,testSet);
requestProps.put(WidgetResourceProvider.WIDGET_VALUES_PROPERTY_ID,testSet);
requestProps.put(WidgetResourceProvider.WIDGET_PROPERTIES_PROPERTY_ID + "/property1","value1");
requestProps.put(WidgetResourceProvider.WIDGET_PROPERTIES_PROPERTY_ID + "/property2","value2");
Request request=PropertyHelper.getCreateRequest(Collections.singleton(requestProps),null);
RequestStatus requestStatus=provider.createResources(request);
Assert.assertTrue(entityCapture.hasCaptured());
WidgetEntity entity=entityCapture.getValue();
Assert.assertNotNull(entity);
Assert.assertEquals(1,requestStatus.getAssociatedResources().size());
Assert.assertEquals(Long.valueOf(1),entity.getClusterId());
Assert.assertEquals("USER",entity.getScope());
Assert.assertEquals("widget name",entity.getWidgetName());
Assert.assertEquals(null,entity.getDefaultSectionName());
Assert.assertEquals("GAUGE",entity.getWidgetType());
Assert.assertEquals("admin",entity.getAuthor());
Assert.assertEquals("[{\"name\":\"value\",\"name2\":\"value2\"}]",entity.getMetrics());
Assert.assertEquals("[{\"name\":\"value\",\"name2\":\"value2\"}]",entity.getWidgetValues());
Assert.assertEquals("{\"property2\":\"value2\",\"property1\":\"value1\"}",entity.getProperties());
verify(amc,clusters,cluster,dao);
}
Class: org.apache.ambari.server.controller.internal.WorkflowResourceProviderTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier expected=new HashSet();
expected.add(createWorkflowResponse("Cluster100","workflow1"));
expected.add(createWorkflowResponse("Cluster100","workflow2"));
expected.add(createWorkflowResponse("Cluster100","workflow3"));
Resource.Type type=Resource.Type.Workflow;
Set propertyIds=PropertyHelper.getPropertyIds(type);
WorkflowFetcher workflowFetcher=createMock(WorkflowFetcher.class);
expect(workflowFetcher.fetchWorkflows(propertyIds,"Cluster100",null)).andReturn(expected).once();
replay(workflowFetcher);
Map keyPropertyIds=PropertyHelper.getKeyPropertyIds(type);
ResourceProvider provider=new WorkflowResourceProvider(propertyIds,keyPropertyIds,workflowFetcher);
Request request=PropertyHelper.getReadRequest(propertyIds);
Predicate predicate=new PredicateBuilder().property(WorkflowResourceProvider.WORKFLOW_CLUSTER_NAME_PROPERTY_ID).equals("Cluster100").toPredicate();
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(3,resources.size());
Set names=new HashSet();
for ( Resource resource : resources) {
String clusterName=(String)resource.getPropertyValue(WorkflowResourceProvider.WORKFLOW_CLUSTER_NAME_PROPERTY_ID);
Assert.assertEquals("Cluster100",clusterName);
names.add((String)resource.getPropertyValue(WorkflowResourceProvider.WORKFLOW_ID_PROPERTY_ID));
}
for ( Resource resource : expected) {
Assert.assertTrue(names.contains(resource.getPropertyValue(WorkflowResourceProvider.WORKFLOW_ID_PROPERTY_ID)));
}
verify(workflowFetcher);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier requestedIds=new HashSet();
requestedIds.add(WorkflowResourceProvider.WORKFLOW_ID_PROPERTY_ID);
Map keyPropertyIds=PropertyHelper.getKeyPropertyIds(Resource.Type.Workflow);
ResourceProvider provider=new TestWorkflowResourceProvider(requestedIds,keyPropertyIds);
Request request=PropertyHelper.getReadRequest(requestedIds);
Predicate predicate=new PredicateBuilder().property(WorkflowResourceProvider.WORKFLOW_ID_PROPERTY_ID).equals("workflow1").toPredicate();
Set resources=provider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
for ( Resource resource : resources) {
String workflowId=(String)resource.getPropertyValue(WorkflowResourceProvider.WORKFLOW_ID_PROPERTY_ID);
Assert.assertEquals("workflow1",workflowId);
}
}
Class: org.apache.ambari.server.controller.metrics.ganglia.GangliaMetricTest InternalCallVerifier BooleanVerifier listTemporalMetrics=new ArrayList();
GangliaMetric instance=new GangliaMetric();
instance.setDs_name("dsName");
instance.setCluster_name("c1");
instance.setHost_name("localhost");
instance.setMetric_name("cpu_wio");
listTemporalMetrics.add(new GangliaMetric.TemporalMetric("111.0",new Long(1362440880)));
listTemporalMetrics.add(new GangliaMetric.TemporalMetric("11.0",new Long(1362440881)));
listTemporalMetrics.add(new GangliaMetric.TemporalMetric("100.0",new Long(1362440882)));
instance.setDatapointsFromList(listTemporalMetrics);
assertTrue(instance.getDatapoints().length == 2);
}
Class: org.apache.ambari.server.controller.metrics.ganglia.GangliaReportPropertyProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier temporalInfoMap=new HashMap();
temporalInfoMap.put(PROPERTY_ID,new TemporalInfoImpl(10L,20L,1L));
Request request=PropertyHelper.getReadRequest(Collections.singleton(PROPERTY_ID),temporalInfoMap);
Assert.assertEquals(1,propertyProvider.populateResources(Collections.singleton(resource),request,null).size());
String expected=(configuration.isGangliaSSL() ? "https" : "http") + "://domU-12-31-39-0E-34-E1.compute-1.internal/ganglia/graph.php?g=load_report&json=1";
Assert.assertEquals(expected,streamProvider.getLastSpec());
Assert.assertEquals(2,PropertyHelper.getProperties(resource).size());
Assert.assertNotNull(resource.getPropertyValue(PROPERTY_ID));
}
Class: org.apache.ambari.server.controller.metrics.timeline.AMSReportPropertyProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > propertyIds=PropertyHelper.getMetricPropertyIds(Resource.Type.Cluster);
AMSReportPropertyProvider propertyProvider=new AMSReportPropertyProvider(propertyIds,streamProvider,sslConfiguration,cacheProvider,metricHostProvider,CLUSTER_NAME_PROPERTY_ID);
String propertyId=PropertyHelper.getPropertyId("metrics/cpu","User");
Resource resource=new ResourceImpl(Resource.Type.Cluster);
resource.setProperty(CLUSTER_NAME_PROPERTY_ID,"c1");
Map temporalInfoMap=new HashMap();
temporalInfoMap.put(propertyId,new TemporalInfoImpl(1416445244800L,1416448936474L,1L));
Request request=PropertyHelper.getReadRequest(Collections.singleton(propertyId),temporalInfoMap);
Set resources=propertyProvider.populateResources(Collections.singleton(resource),request,null);
Assert.assertEquals(1,resources.size());
Resource res=resources.iterator().next();
Map properties=PropertyHelper.getProperties(resources.iterator().next());
Assert.assertNotNull(properties);
URIBuilder uriBuilder=AMSPropertyProvider.getAMSUriBuilder("localhost",8188);
uriBuilder.addParameter("metricNames","cpu_user");
uriBuilder.addParameter("appId","HOST");
uriBuilder.addParameter("startTime","1416445244800");
uriBuilder.addParameter("endTime","1416448936474");
Assert.assertEquals(uriBuilder.toString(),streamProvider.getLastSpec());
Number[][] val=(Number[][])res.getPropertyValue("metrics/cpu/User");
Assert.assertEquals(111,val.length);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > propertyIds=PropertyHelper.getMetricPropertyIds(Resource.Type.Cluster);
AMSReportPropertyProvider propertyProvider=new AMSReportPropertyProvider(propertyIds,streamProvider,sslConfiguration,cacheProvider,metricHostProvider,CLUSTER_NAME_PROPERTY_ID);
String propertyId=PropertyHelper.getPropertyId("metrics/cpu","User._sum");
Resource resource=new ResourceImpl(Resource.Type.Cluster);
resource.setProperty(CLUSTER_NAME_PROPERTY_ID,"c1");
Map temporalInfoMap=new HashMap();
temporalInfoMap.put(propertyId,new TemporalInfoImpl(1432033257812L,1432035927922L,1L));
Request request=PropertyHelper.getReadRequest(Collections.singleton(propertyId),temporalInfoMap);
Set resources=propertyProvider.populateResources(Collections.singleton(resource),request,null);
Assert.assertEquals(1,resources.size());
Resource res=resources.iterator().next();
Map properties=PropertyHelper.getProperties(resources.iterator().next());
Assert.assertNotNull(properties);
URIBuilder uriBuilder=AMSPropertyProvider.getAMSUriBuilder("localhost",8188);
uriBuilder.addParameter("metricNames","cpu_user._sum");
uriBuilder.addParameter("appId","HOST");
uriBuilder.addParameter("startTime","1432033257812");
uriBuilder.addParameter("endTime","1432035927922");
Assert.assertEquals(uriBuilder.toString(),streamProvider.getLastSpec());
Number[][] val=(Number[][])res.getPropertyValue("metrics/cpu/User._sum");
Assert.assertEquals(90,val.length);
}
Class: org.apache.ambari.server.controller.metrics.timeline.MetricsPaddingMethodTest InternalCallVerifier EqualityVerifier inputValues=new TreeMap();
long seconds=1000;
long minute=60 * seconds;
long hour=60 * minute;
long day=24 * hour;
inputValues.clear();
for (int i=5; i >= 1; i--) {
inputValues.put(now - i * minute,i + 0.0);
}
timelineMetric.setMetricValues(inputValues);
TemporalInfo temporalInfo=getTemporalInfo(now - 2 * hour - 1 * minute,now,null);
paddingMethod.applyPaddingStrategy(timelineMetric,temporalInfo);
TreeMap values=(TreeMap)timelineMetric.getMetricValues();
Assert.assertEquals(122,values.size());
Assert.assertEquals(new Long(now - 2 * hour - 1 * minute),values.keySet().iterator().next());
inputValues.clear();
for (int i=5; i >= 1; i--) {
inputValues.put(now - i * hour,i + 0.0);
}
timelineMetric.setMetricValues(inputValues);
temporalInfo=getTemporalInfo(now - 1 * day - 1 * hour,now,null);
paddingMethod.applyPaddingStrategy(timelineMetric,temporalInfo);
values=(TreeMap)timelineMetric.getMetricValues();
Assert.assertEquals(26,values.size());
Assert.assertEquals(new Long(now - 1 * day - 1 * hour),values.keySet().iterator().next());
inputValues.clear();
inputValues.put(now - day,1.0);
timelineMetric.setMetricValues(inputValues);
temporalInfo=getTemporalInfo(now - 40 * day,now,null);
paddingMethod.applyPaddingStrategy(timelineMetric,temporalInfo);
values=(TreeMap)timelineMetric.getMetricValues();
Assert.assertEquals(41,values.size());
Assert.assertEquals(new Long(now - 40 * day),values.keySet().iterator().next());
}
InternalCallVerifier EqualityVerifier inputValues=new TreeMap();
inputValues.put(now - 1000,1.0d);
timelineMetric.setMetricValues(inputValues);
TemporalInfo temporalInfo=getTemporalInfo(now - 10000,now,1000l);
paddingMethod.applyPaddingStrategy(timelineMetric,temporalInfo);
TreeMap values=(TreeMap)timelineMetric.getMetricValues();
Assert.assertEquals(11,values.size());
Assert.assertEquals(new Long(now - 10000),values.keySet().iterator().next());
Assert.assertEquals(new Long(now),values.descendingKeySet().iterator().next());
Assert.assertEquals(0.0,values.values().iterator().next());
}
InternalCallVerifier EqualityVerifier inputValues=new TreeMap();
inputValues.put(now - 1000,1.0d);
inputValues.put(now - 2000,2.0d);
inputValues.put(now - 3000,3.0d);
timelineMetric.setMetricValues(inputValues);
TemporalInfo temporalInfo=getTemporalInfo(now - 10000,now,1l);
paddingMethod.applyPaddingStrategy(timelineMetric,temporalInfo);
TreeMap values=(TreeMap)timelineMetric.getMetricValues();
Assert.assertEquals(11,values.size());
Assert.assertEquals(new Long(now - 10000),values.keySet().iterator().next());
Assert.assertEquals(new Long(now),values.descendingKeySet().iterator().next());
Assert.assertEquals(null,values.values().iterator().next());
}
InternalCallVerifier EqualityVerifier inputValues=new TreeMap();
inputValues.put(now - 100,1.0d);
inputValues.put(now - 200,2.0d);
inputValues.put(now - 300,3.0d);
timelineMetric.setMetricValues(inputValues);
TemporalInfo temporalInfo=getTemporalInfo(now - 1000,now,10l);
paddingMethod.applyPaddingStrategy(timelineMetric,temporalInfo);
TreeMap values=(TreeMap)timelineMetric.getMetricValues();
Assert.assertEquals(3,values.size());
}
InternalCallVerifier EqualityVerifier inputValues=new TreeMap();
inputValues.put(now,0.0d);
inputValues.put(now - 1000,1.0d);
inputValues.put(now - 2000,2.0d);
inputValues.put(now - 3000,3.0d);
timelineMetric.setMetricValues(inputValues);
TemporalInfo temporalInfo=getTemporalInfo(now - 3000,now,1l);
paddingMethod.applyPaddingStrategy(timelineMetric,temporalInfo);
TreeMap values=(TreeMap)timelineMetric.getMetricValues();
Assert.assertEquals(4,values.size());
Assert.assertEquals(new Long(now - 3000),values.keySet().iterator().next());
Assert.assertEquals(new Long(now),values.descendingKeySet().iterator().next());
}
InternalCallVerifier EqualityVerifier inputValues=new TreeMap();
inputValues.put(now - 1000,1.0d);
inputValues.put(now - 2000,2.0d);
inputValues.put(now - 3000,3.0d);
timelineMetric.setMetricValues(inputValues);
TemporalInfo temporalInfo=getTemporalInfo(now - 10000,now,1l);
paddingMethod.applyPaddingStrategy(timelineMetric,temporalInfo);
TreeMap values=(TreeMap)timelineMetric.getMetricValues();
Assert.assertEquals(11,values.size());
Assert.assertEquals(new Long(now - 10000),values.keySet().iterator().next());
Assert.assertEquals(new Long(now),values.descendingKeySet().iterator().next());
Assert.assertEquals(0.0,values.values().iterator().next());
}
InternalCallVerifier EqualityVerifier inputValues=new TreeMap();
inputValues.put(now - 1000,1.0d);
timelineMetric.setMetricValues(inputValues);
TemporalInfo temporalInfo=getTemporalInfo(now - 10000,now,null);
paddingMethod.applyPaddingStrategy(timelineMetric,temporalInfo);
TreeMap values=(TreeMap)timelineMetric.getMetricValues();
Assert.assertEquals(1,values.size());
Assert.assertEquals(new Long(now - 1000),values.keySet().iterator().next());
Assert.assertEquals(1.0,values.values().iterator().next());
}
Class: org.apache.ambari.server.controller.metrics.timeline.cache.TimelineMetricCacheSizingTest InternalCallVerifier BooleanVerifier metricNames=new HashSet<>();
String metric1="prefix1.suffix1.suffix2.actualNamePrefix.longMetricName1";
String metric2="prefix1.suffix1.suffix2.actualNamePrefix.longMetricName2";
String metric3="prefix1.suffix1.suffix2.actualNamePrefix.longMetricName3";
String metric4="prefix1.suffix1.suffix2.actualNamePrefix.longMetricName4";
String metric5="prefix1.suffix1.suffix2.actualNamePrefix.longMetricName5";
String metric6="prefix1.suffix1.suffix2.actualNamePrefix.longMetricName6";
metricNames.add(metric1);
metricNames.add(metric2);
metricNames.add(metric3);
metricNames.add(metric4);
metricNames.add(metric5);
metricNames.add(metric6);
long now=System.currentTimeMillis();
TemporalInfo temporalInfo=new TemporalInfoImpl(now - 1000,now,15);
TimelineAppMetricCacheKey key=new TimelineAppMetricCacheKey(metricNames,"KAFKA_BROKER",temporalInfo);
key.setSpec("http://104.196.94.129:6188/ws/v1/timeline/metrics?metricNames=" + "jvm.JvmMetrics.MemHeapCommittedM&appId=RESOURCEMANAGER&" + "startTime=1439522640000&endTime=1440127440000&precision=hours");
TimelineMetrics metrics=new TimelineMetrics();
metrics.getMetrics().add(getSampleTimelineMetric(metric1));
metrics.getMetrics().add(getSampleTimelineMetric(metric2));
metrics.getMetrics().add(getSampleTimelineMetric(metric3));
metrics.getMetrics().add(getSampleTimelineMetric(metric4));
metrics.getMetrics().add(getSampleTimelineMetric(metric5));
metrics.getMetrics().add(getSampleTimelineMetric(metric6));
TimelineMetricsCacheValue value=new TimelineMetricsCacheValue(now - 1000,now,metrics,null);
TimelineMetricsCacheSizeOfEngine customSizeOfEngine=new TimelineMetricsCacheSizeOfEngine();
long bytesFromReflectionEngine=reflectionSizeOf.deepSizeOf(50000,false,key).getCalculated() + reflectionSizeOf.deepSizeOf(50000,false,value).getCalculated();
long bytesFromCustomSizeOfEngine=customSizeOfEngine.sizeOf(key,value,null).getCalculated();
long sampleSizeInMB=bytesFromReflectionEngine / (1024 * 1024);
long discrepancyInKB=Math.abs(bytesFromCustomSizeOfEngine - bytesFromReflectionEngine) / 1024;
Assert.assertTrue("Sample size is " + sampleSizeInMB + ", expected to be"+ "greater that 10 MB",sampleSizeInMB > 10);
Assert.assertTrue("Discrepancy in values is " + discrepancyInKB + ", "+ "expected to be less than 10K. "+ "Bytes from reflection = "+ bytesFromReflectionEngine+ ", bytes from custom sizing engine = "+ bytesFromCustomSizeOfEngine,discrepancyInKB < 10);
}
Class: org.apache.ambari.server.controller.metrics.timeline.cache.TimelineMetricCacheTest APIUtilityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier HybridVerifier metricValues=new TreeMap();
metricValues.put(now + 100,1.0);
metricValues.put(now + 200,2.0);
metricValues.put(now + 300,3.0);
timelineMetric.setMetricValues(metricValues);
metrics.getMetrics().add(timelineMetric);
TimelineMetricCacheEntryFactory cacheEntryFactory=createMock(TimelineMetricCacheEntryFactory.class);
TimelineAppMetricCacheKey queryKey=new TimelineAppMetricCacheKey(Collections.singleton("cpu_user"),"app1",new TemporalInfoImpl(now,now + 1000,1));
TimelineMetricsCacheValue value=new TimelineMetricsCacheValue(now,now + 1000,metrics,null);
TimelineAppMetricCacheKey testKey=new TimelineAppMetricCacheKey(Collections.singleton("cpu_user"),"app1",new TemporalInfoImpl(now,now + 2000,1));
expect(cacheEntryFactory.createEntry(anyObject())).andReturn(value);
cacheEntryFactory.updateEntryValue(testKey,value);
expectLastCall().once();
replay(cacheEntryFactory);
TimelineMetricCacheProvider cacheProvider=createMockBuilder(TimelineMetricCacheProvider.class).addMockedMethod("createCacheConfiguration").withConstructor(configuration,cacheEntryFactory).createNiceMock();
expect(cacheProvider.createCacheConfiguration()).andReturn(createTestCacheConfiguration(configuration)).anyTimes();
replay(cacheProvider);
TimelineMetricCache cache=cacheProvider.getTimelineMetricsCache();
metrics=cache.getAppTimelineMetricsFromCache(queryKey);
List metricsList=metrics.getMetrics();
Assert.assertEquals(1,metricsList.size());
TimelineMetric metric=metricsList.iterator().next();
Assert.assertEquals("cpu_user",metric.getMetricName());
Assert.assertEquals("app1",metric.getAppId());
Assert.assertSame(metricValues,metric.getMetricValues());
metrics=cache.getAppTimelineMetricsFromCache(testKey);
metricsList=metrics.getMetrics();
Assert.assertEquals(1,metricsList.size());
Assert.assertEquals("cpu_user",metric.getMetricName());
Assert.assertEquals("app1",metric.getAppId());
Assert.assertSame(metricValues,metric.getMetricValues());
verify(configuration,cacheEntryFactory);
}
InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier metricValues=new TreeMap();
metricValues.put(now - 100,1.0);
metricValues.put(now - 200,2.0);
metricValues.put(now - 300,3.0);
timelineMetric1.setMetricValues(metricValues);
final TimelineMetric timelineMetric2=new TimelineMetric();
timelineMetric2.setMetricName("cpu_nice");
timelineMetric2.setAppId("app1");
metricValues=new TreeMap();
metricValues.put(now + 400,1.0);
metricValues.put(now + 500,2.0);
metricValues.put(now + 600,3.0);
timelineMetric2.setMetricValues(metricValues);
TimelineMetrics existingMetrics=new TimelineMetrics();
existingMetrics.getMetrics().add(timelineMetric1);
existingMetrics.getMetrics().add(timelineMetric2);
TimelineMetricsCacheValue existingMetricValue=new TimelineMetricsCacheValue(now - 1000,now + 1000,existingMetrics,null);
TimelineMetrics newMetrics=new TimelineMetrics();
TimelineMetric timelineMetric3=new TimelineMetric();
timelineMetric3.setMetricName("cpu_user");
timelineMetric3.setAppId("app1");
metricValues=new TreeMap();
metricValues.put(now + 1400,1.0);
metricValues.put(now + 1500,2.0);
metricValues.put(now + 1600,3.0);
timelineMetric3.setMetricValues(metricValues);
newMetrics.getMetrics().add(timelineMetric3);
factory.updateTimelineMetricsInCache(newMetrics,existingMetricValue,now,now + 2000,false);
Assert.assertEquals(2,existingMetricValue.getTimelineMetrics().getMetrics().size());
TimelineMetric newMetric1=null;
TimelineMetric newMetric2=null;
for ( TimelineMetric metric : existingMetricValue.getTimelineMetrics().getMetrics()) {
if (metric.getMetricName().equals("cpu_user")) {
newMetric1=metric;
}
if (metric.getMetricName().equals("cpu_nice")) {
newMetric2=metric;
}
}
Assert.assertNotNull(newMetric1);
Assert.assertNotNull(newMetric2);
Assert.assertEquals(3,newMetric1.getMetricValues().size());
Assert.assertEquals(3,newMetric2.getMetricValues().size());
Map newMetricsMap=newMetric1.getMetricValues();
Iterator metricKeyIterator=newMetricsMap.keySet().iterator();
Assert.assertEquals(now + 1400,metricKeyIterator.next().longValue());
Assert.assertEquals(now + 1500,metricKeyIterator.next().longValue());
Assert.assertEquals(now + 1600,metricKeyIterator.next().longValue());
verify(configuration,factory);
}
InternalCallVerifier BooleanVerifier (){
{
add("cpu_num._avg");
add("proc_run._avg");
}
}
,"HOST",temporalInfo);
TimelineAppMetricCacheKey key2=new TimelineAppMetricCacheKey(new HashSet(){
{
add("cpu_num._avg");
}
}
,"HOST",temporalInfo);
Assert.assertFalse(key1.equals(key2));
Assert.assertFalse(key2.equals(key1));
key2.getMetricNames().add("proc_run._avg");
Assert.assertTrue(key1.equals(key2));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier valueMap=new HashMap();
TimelineMetric timelineMetric=new TimelineMetric();
timelineMetric.setMetricName("cpu_user");
timelineMetric.setAppId("app1");
TreeMap metricValues=new TreeMap();
for (long i=1 * year - 1 * day; i >= 0; i-=1 * day) {
metricValues.put(now - i,1.0);
}
timelineMetric.setMetricValues(metricValues);
valueMap.put("cpu_user",timelineMetric);
List timelineMetricList=new ArrayList<>();
timelineMetricList.add(timelineMetric);
TimelineMetrics metrics=new TimelineMetrics();
metrics.setMetrics(timelineMetricList);
TimelineAppMetricCacheKey key=new TimelineAppMetricCacheKey(Collections.singleton("cpu_user"),"app1",new TemporalInfoImpl(now - 1 * year,now,1));
key.setSpec("");
Map newValueMap=new HashMap();
TimelineMetric newTimelineMetric=new TimelineMetric();
newTimelineMetric.setMetricName("cpu_user");
newTimelineMetric.setAppId("app1");
TreeMap newMetricValues=new TreeMap();
for (long i=1 * hour; i <= 2 * day; i+=hour) {
newMetricValues.put(now - 1 * day + i,2.0);
}
newTimelineMetric.setMetricValues(newMetricValues);
newValueMap.put("cpu_user",newTimelineMetric);
List newTimelineMetricList=new ArrayList<>();
newTimelineMetricList.add(newTimelineMetric);
TimelineMetrics newMetrics=new TimelineMetrics();
newMetrics.setMetrics(newTimelineMetricList);
TimelineAppMetricCacheKey newKey=new TimelineAppMetricCacheKey(Collections.singleton("cpu_user"),"app1",new TemporalInfoImpl(now - 1 * day,now + 2 * day,1));
newKey.setSpec("");
MetricsRequestHelper metricsRequestHelperForGets=createMock(MetricsRequestHelper.class);
expect(metricsRequestHelperForGets.fetchTimelineMetrics(EasyMock.isA(URIBuilder.class),anyLong(),anyLong())).andReturn(metrics).andReturn(newMetrics);
replay(metricsRequestHelperForGets);
TimelineMetricCacheEntryFactory cacheEntryFactory=createMockBuilder(TimelineMetricCacheEntryFactory.class).withConstructor(configuration).createMock();
Field requestHelperField=TimelineMetricCacheEntryFactory.class.getDeclaredField("requestHelperForGets");
requestHelperField.setAccessible(true);
requestHelperField.set(cacheEntryFactory,metricsRequestHelperForGets);
requestHelperField=TimelineMetricCacheEntryFactory.class.getDeclaredField("requestHelperForUpdates");
requestHelperField.setAccessible(true);
requestHelperField.set(cacheEntryFactory,metricsRequestHelperForGets);
replay(cacheEntryFactory);
TimelineMetricCacheProvider cacheProvider=createMockBuilder(TimelineMetricCacheProvider.class).addMockedMethod("createCacheConfiguration").withConstructor(configuration,cacheEntryFactory).createNiceMock();
expect(cacheProvider.createCacheConfiguration()).andReturn(createTestCacheConfiguration(configuration)).anyTimes();
replay(cacheProvider);
TimelineMetricCache cache=cacheProvider.getTimelineMetricsCache();
metrics=cache.getAppTimelineMetricsFromCache(key);
List metricsList=metrics.getMetrics();
Assert.assertEquals(1,metricsList.size());
TimelineMetric metric=metricsList.iterator().next();
Assert.assertEquals("cpu_user",metric.getMetricName());
Assert.assertEquals("app1",metric.getAppId());
Assert.assertEquals(metricValues,metric.getMetricValues());
metrics=cache.getAppTimelineMetricsFromCache(newKey);
metricsList=metrics.getMetrics();
Assert.assertEquals(1,metricsList.size());
Assert.assertEquals("cpu_user",metric.getMetricName());
Assert.assertEquals("app1",metric.getAppId());
Assert.assertEquals(newMetricValues,metric.getMetricValues());
verify(configuration,metricsRequestHelperForGets,cacheEntryFactory);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.controller.predicate.AndPredicateTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (propertyId1,"v1");
EqualsPredicate predicate2=new EqualsPredicate(propertyId2,"v2");
EqualsPredicate predicate3=new EqualsPredicate(propertyId3,"v3");
AndPredicate andPredicate=new AndPredicate(predicate1,predicate2,predicate3);
Set ids=andPredicate.getPropertyIds();
Assert.assertEquals(3,ids.size());
Assert.assertTrue(ids.contains(propertyId1));
Assert.assertTrue(ids.contains(propertyId2));
Assert.assertTrue(ids.contains(propertyId3));
}
InternalCallVerifier BooleanVerifier (propertyId1,"v1");
EqualsPredicate predicate2=new EqualsPredicate(propertyId2,"v2");
EqualsPredicate predicate3=new EqualsPredicate(propertyId3,"v3");
AndPredicate andPredicate=new AndPredicate(predicate1,predicate2,predicate3);
resource.setProperty(propertyId1,"v1");
resource.setProperty(propertyId2,"monkey");
resource.setProperty(propertyId3,"v3");
Assert.assertFalse(andPredicate.evaluate(resource));
resource.setProperty(propertyId2,"v2");
Assert.assertTrue(andPredicate.evaluate(resource));
}
Class: org.apache.ambari.server.controller.predicate.CategoryIsEmptyPredicateTest InternalCallVerifier BooleanVerifier mapProperty=new HashMap();
resource.setProperty(propertyId,mapProperty);
Assert.assertTrue(predicate.evaluate(resource));
mapProperty.put("foo","bar");
Assert.assertFalse(predicate.evaluate(resource));
}
InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.controller.predicate.CategoryPredicateTest InternalCallVerifier IdentityVerifier Class: org.apache.ambari.server.controller.predicate.EqualsPredicateTest InternalCallVerifier BooleanVerifier (propertyId,null);
resource.setProperty(propertyId,"monkey");
Assert.assertFalse(predicate.evaluate(resource));
resource.setProperty(propertyId,null);
Assert.assertTrue(predicate.evaluate(resource));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (propertyId,"bar");
Set ids=predicate.getPropertyIds();
Assert.assertEquals(1,ids.size());
Assert.assertTrue(ids.contains(propertyId));
}
InternalCallVerifier BooleanVerifier (propertyId,"1");
resource.setProperty(propertyId,"1");
Assert.assertTrue(predicate.evaluate(resource));
resource.setProperty(propertyId,"2");
Assert.assertFalse(predicate.evaluate(resource));
resource.setProperty(propertyId,"5");
Assert.assertFalse(predicate.evaluate(resource));
}
InternalCallVerifier BooleanVerifier (propertyId,"bar");
resource.setProperty(propertyId,"monkey");
Assert.assertFalse(predicate.evaluate(resource));
resource.setProperty(propertyId,"bar");
Assert.assertTrue(predicate.evaluate(resource));
propertyId=PropertyHelper.getPropertyId("category1","fun");
predicate=new EqualsPredicate(propertyId,"bar");
Assert.assertFalse(predicate.evaluate(resource));
}
Class: org.apache.ambari.server.controller.predicate.FilterPredicateTest InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier ids=predicate.getPropertyIds();
Assert.assertEquals(1,ids.size());
Assert.assertTrue(ids.contains(propertyId));
}
Class: org.apache.ambari.server.controller.predicate.GreaterEqualsPredicateTest InternalCallVerifier BooleanVerifier (propertyId,10);
resource.setProperty(propertyId,1);
Assert.assertFalse(predicate.evaluate(resource));
resource.setProperty(propertyId,100);
Assert.assertTrue(predicate.evaluate(resource));
resource.setProperty(propertyId,10);
Assert.assertTrue(predicate.evaluate(resource));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (propertyId,10);
Set ids=predicate.getPropertyIds();
Assert.assertEquals(1,ids.size());
Assert.assertTrue(ids.contains(propertyId));
}
Class: org.apache.ambari.server.controller.predicate.GreaterPredicateTest InternalCallVerifier BooleanVerifier (propertyId,0.1);
resource.setProperty(propertyId,1.3);
Assert.assertTrue(predicate.evaluate(resource));
resource.setProperty(propertyId,0.06);
Assert.assertFalse(predicate.evaluate(resource));
resource.setProperty(propertyId,100.3);
Assert.assertTrue(predicate.evaluate(resource));
}
InternalCallVerifier BooleanVerifier (propertyId,10);
resource.setProperty(propertyId,1);
Assert.assertFalse(predicate.evaluate(resource));
resource.setProperty(propertyId,100);
Assert.assertTrue(predicate.evaluate(resource));
resource.setProperty(propertyId,10);
Assert.assertFalse(predicate.evaluate(resource));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (propertyId,10);
Set ids=predicate.getPropertyIds();
Assert.assertEquals(1,ids.size());
Assert.assertTrue(ids.contains(propertyId));
}
Class: org.apache.ambari.server.controller.predicate.LessEqualsPredicateTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (propertyId,10);
Set ids=predicate.getPropertyIds();
Assert.assertEquals(1,ids.size());
Assert.assertTrue(ids.contains(propertyId));
}
InternalCallVerifier BooleanVerifier (propertyId,10);
resource.setProperty(propertyId,1);
Assert.assertTrue(predicate.evaluate(resource));
resource.setProperty(propertyId,100);
Assert.assertFalse(predicate.evaluate(resource));
resource.setProperty(propertyId,10);
Assert.assertTrue(predicate.evaluate(resource));
}
Class: org.apache.ambari.server.controller.predicate.LessPredicateTest InternalCallVerifier BooleanVerifier (propertyId,10);
resource.setProperty(propertyId,1);
Assert.assertTrue(predicate.evaluate(resource));
resource.setProperty(propertyId,100);
Assert.assertFalse(predicate.evaluate(resource));
resource.setProperty(propertyId,10);
Assert.assertFalse(predicate.evaluate(resource));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (propertyId,1);
Set ids=predicate.getPropertyIds();
Assert.assertEquals(1,ids.size());
Assert.assertTrue(ids.contains(propertyId));
}
Class: org.apache.ambari.server.controller.predicate.NotPredicateTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (propertyId,"bar");
Set ids=predicate.getPropertyIds();
Assert.assertEquals(1,ids.size());
Assert.assertTrue(ids.contains(propertyId));
}
InternalCallVerifier BooleanVerifier (propertyId,"bar");
NotPredicate notPredicate=new NotPredicate(predicate);
resource.setProperty(propertyId,"monkey");
Assert.assertTrue(notPredicate.evaluate(resource));
resource.setProperty(propertyId,"bar");
Assert.assertFalse(notPredicate.evaluate(resource));
}
Class: org.apache.ambari.server.controller.predicate.OrPredicateTest InternalCallVerifier BooleanVerifier (propertyId1,"v1");
EqualsPredicate predicate2=new EqualsPredicate(propertyId2,"v2");
EqualsPredicate predicate3=new EqualsPredicate(propertyId3,"v3");
OrPredicate orPredicate=new OrPredicate(predicate1,predicate2,predicate3);
resource.setProperty(propertyId1,"big");
resource.setProperty(propertyId2,"monkey");
resource.setProperty(propertyId3,"runner");
Assert.assertFalse(orPredicate.evaluate(resource));
resource.setProperty(propertyId2,"v2");
Assert.assertTrue(orPredicate.evaluate(resource));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (propertyId1,"v1");
EqualsPredicate predicate2=new EqualsPredicate(propertyId2,"v2");
EqualsPredicate predicate3=new EqualsPredicate(propertyId3,"v3");
OrPredicate orPredicate=new OrPredicate(predicate1,predicate2,predicate3);
Set ids=orPredicate.getPropertyIds();
Assert.assertEquals(3,ids.size());
Assert.assertTrue(ids.contains(propertyId1));
Assert.assertTrue(ids.contains(propertyId2));
Assert.assertTrue(ids.contains(propertyId3));
}
Class: org.apache.ambari.server.controller.predicate.PredicateVisitorTest InternalCallVerifier IdentityVerifier NullVerifier HybridVerifier (propertyId,"bar");
TestPredicateVisitor visitor=new TestPredicateVisitor();
equalsPredicate.accept(visitor);
Assert.assertSame(equalsPredicate,visitor.visitedComparisonPredicate);
Assert.assertNull(visitor.visitedArrayPredicate);
Assert.assertNull(visitor.visitedUnaryPredicate);
AndPredicate andPredicate=new AndPredicate(equalsPredicate);
visitor=new TestPredicateVisitor();
andPredicate.accept(visitor);
Assert.assertNull(visitor.visitedComparisonPredicate);
Assert.assertSame(andPredicate,visitor.visitedArrayPredicate);
Assert.assertNull(visitor.visitedUnaryPredicate);
NotPredicate notPredicate=new NotPredicate(andPredicate);
visitor=new TestPredicateVisitor();
notPredicate.accept(visitor);
Assert.assertNull(visitor.visitedComparisonPredicate);
Assert.assertNull(visitor.visitedArrayPredicate);
Assert.assertSame(notPredicate,visitor.visitedUnaryPredicate);
CategoryPredicate categoryPredicate=new CategoryIsEmptyPredicate("cat1");
visitor=new TestPredicateVisitor();
categoryPredicate.accept(visitor);
Assert.assertNull(visitor.visitedComparisonPredicate);
Assert.assertNull(visitor.visitedArrayPredicate);
Assert.assertNull(visitor.visitedUnaryPredicate);
Assert.assertSame(categoryPredicate,visitor.visitedCategoryPredicate);
}
Class: org.apache.ambari.server.controller.spi.ResourceTest UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.controller.test.BufferedThreadPoolExecutorCompletionServiceTest IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier queue=new LinkedBlockingQueue();
ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,30000,TimeUnit.MILLISECONDS,queue);
BufferedThreadPoolExecutorCompletionService service=new BufferedThreadPoolExecutorCompletionService<>(threadPoolExecutor);
for (int tc=0; tc < TASKS_COUNT; tc++) {
service.submit(new Runnable(){
@Override public void run(){
try {
longOp();
}
catch ( InterruptedException e) {
e.printStackTrace();
}
}
}
,null);
}
Thread.sleep(500);
Assert.assertEquals(CORE_POOL_SIZE,threadPoolExecutor.getActiveCount());
for (int tc=0; tc < TASKS_COUNT; tc++) {
Future take=service.take();
Assert.assertTrue(take.isDone());
Assert.assertTrue("No more than CORE_POOL_SIZE threads should be launched",threadPoolExecutor.getActiveCount() <= CORE_POOL_SIZE);
}
threadPoolExecutor.shutdown();
}
IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier queue=new LinkedBlockingQueue(CORE_POOL_SIZE);
ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,30000,TimeUnit.MILLISECONDS,queue);
BufferedThreadPoolExecutorCompletionService service=new BufferedThreadPoolExecutorCompletionService<>(threadPoolExecutor);
for (int tc=0; tc < TASKS_COUNT; tc++) {
service.submit(new Runnable(){
@Override public void run(){
try {
longOp();
}
catch ( InterruptedException e) {
e.printStackTrace();
}
}
}
,null);
}
Thread.sleep(500);
Assert.assertEquals(MAX_POOL_SIZE,threadPoolExecutor.getActiveCount());
for (int tc=0; tc < TASKS_COUNT; tc++) {
Future take=service.take();
Assert.assertTrue(take.isDone());
Assert.assertTrue("No more than MAX_POOL_SIZE threads should be launched",threadPoolExecutor.getActiveCount() <= MAX_POOL_SIZE);
}
threadPoolExecutor.shutdown();
}
IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier queue=new LinkedBlockingQueue(CORE_POOL_SIZE);
ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,30000,TimeUnit.MILLISECONDS,queue);
BufferedThreadPoolExecutorCompletionService service=new BufferedThreadPoolExecutorCompletionService<>(threadPoolExecutor);
for (int tc=0; tc < TASKS_COUNT; tc++) {
service.submit(new Runnable(){
@Override public void run(){
try {
longOp();
}
catch ( InterruptedException e) {
e.printStackTrace();
}
}
}
,null);
}
Thread.sleep(500);
Assert.assertEquals(TASKS_COUNT - CORE_POOL_SIZE,threadPoolExecutor.getActiveCount());
for (int tc=0; tc < TASKS_COUNT; tc++) {
Future take=service.take();
Assert.assertTrue(take.isDone());
Assert.assertTrue("No more than TASKS_COUNT threads should be launched",threadPoolExecutor.getActiveCount() <= TASKS_COUNT);
}
threadPoolExecutor.shutdown();
}
IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier service=new BufferedThreadPoolExecutorCompletionService<>(threadPoolExecutor);
for (int tc=0; tc < TASKS_COUNT; tc++) {
service.submit(new Runnable(){
@Override public void run(){
try {
longOp();
}
catch ( InterruptedException e) {
e.printStackTrace();
}
}
}
,null);
}
Thread.sleep(500);
Assert.assertEquals(MAX_POOL_SIZE,threadPoolExecutor.getActiveCount());
for (int tc=0; tc < TASKS_COUNT; tc++) {
Future take=service.take();
Assert.assertTrue(take.isDone());
Assert.assertTrue("No more than MAX_POOL_SIZE threads should be launched",threadPoolExecutor.getActiveCount() <= MAX_POOL_SIZE);
}
threadPoolExecutor.shutdown();
}
Class: org.apache.ambari.server.controller.utilities.PredicateBuilderTest InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier UtilityVerifier InternalCallVerifier IdentityVerifier HybridVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.customactions.ActionDefinitionManagerTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.events.EventsTest InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier componentHosts=m_cluster.getServiceComponentHosts(HOSTNAME);
ServiceComponentHost componentHost=componentHosts.get(0);
componentHost.setMaintenanceState(MaintenanceState.OFF);
Assert.assertTrue(m_listener.isAmbariEventReceived(eventClass));
Assert.assertEquals(1,m_listener.getAmbariEventReceivedCount(eventClass));
m_listener.reset();
Assert.assertFalse(m_listener.isAmbariEventReceived(eventClass));
Host host=m_clusters.getHost(HOSTNAME);
host.setMaintenanceState(m_cluster.getClusterId(),MaintenanceState.ON);
host.setMaintenanceState(m_cluster.getClusterId(),MaintenanceState.OFF);
Assert.assertTrue(m_listener.isAmbariEventReceived(eventClass));
Assert.assertEquals(2,m_listener.getAmbariEventReceivedCount(eventClass));
}
InternalCallVerifier BooleanVerifier TestInitializer InternalCallVerifier NullVerifier HybridVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","6.4");
host.setHostAttributes(hostAttributes);
host.setState(HostState.HEALTHY);
host.persist();
m_cluster=m_clusters.getCluster(m_clusterName);
Assert.assertNotNull(m_cluster);
m_cluster.setDesiredStackVersion(stackId);
m_helper.getOrCreateRepositoryVersion(stackId,stackId.getStackVersion());
m_cluster.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
m_clusters.mapHostToCluster(HOSTNAME,m_clusterName);
}
InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier ambariEvents=m_listener.getAmbariEventInstances(eventClass);
Assert.assertEquals(1,ambariEvents.size());
Assert.assertEquals(AmbariEventType.CLUSTER_RENAME,ambariEvents.get(0).getType());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hdfsDefinitions=m_definitionDao.findByService(m_cluster.getClusterId(),"HDFS");
Assert.assertTrue(hdfsDefinitions.size() > 0);
AlertDefinitionEntity definition=hdfsDefinitions.get(0);
m_cluster.getService("HDFS").delete();
Assert.assertTrue(m_listener.isAmbariEventReceived(eventClass));
hdfsDefinitions=m_definitionDao.findByService(m_cluster.getClusterId(),"HDFS");
Assert.assertEquals(0,hdfsDefinitions.size());
}
Class: org.apache.ambari.server.events.listeners.upgrade.HostVersionOutOfSyncListenerTest BranchVerifier InternalCallVerifier EqualityVerifier h2Versions=hostVersionDAO.findByHost("h2");
for ( HostVersionEntity hostVersionEntity : h2Versions) {
if (hostVersionEntity.getRepositoryVersion().toString().equals("2.2.0-2086")) {
assertEquals(hostVersionEntity.getState(),RepositoryVersionState.CURRENT);
}
else {
assertEquals(hostVersionEntity.getState(),RepositoryVersionState.OUT_OF_SYNC);
}
}
}
BranchVerifier InternalCallVerifier EqualityVerifier hostList=new ArrayList();
hostList.add("h1");
hostList.add("h2");
hostList.add("h3");
Map> hdfsTopology=new HashMap>();
hdfsTopology.put("NAMENODE",Collections.singletonList(0));
hdfsTopology.put("SECONDARY_NAMENODE",Collections.singletonList(1));
List datanodeHosts=Arrays.asList(0,1);
hdfsTopology.put("DATANODE",new ArrayList(datanodeHosts));
addService(c1,hostList,hdfsTopology,"HDFS");
Set changedHosts=new HashSet();
changedHosts.add("h1");
changedHosts.add("h2");
List hostVersions=hostVersionDAO.findAll();
assertRepoVersionState(stackId.getStackId(),INSTALLED_VERSION,RepositoryVersionState.INSTALLED);
assertRepoVersionState(yaStackId.getStackId(),INSTALLED_VERSION_2,RepositoryVersionState.INSTALLED);
for ( HostVersionEntity hostVersionEntity : hostVersions) {
if (hostVersionEntity.getRepositoryVersion().getVersion().equals(INSTALLED_VERSION) || hostVersionEntity.getRepositoryVersion().getVersion().equals(INSTALLED_VERSION_2)) {
if (changedHosts.contains(hostVersionEntity.getHostName())) {
assertEquals(hostVersionEntity.getState(),RepositoryVersionState.OUT_OF_SYNC);
}
else {
assertEquals(hostVersionEntity.getState(),RepositoryVersionState.INSTALLED);
}
}
}
}
BranchVerifier InternalCallVerifier EqualityVerifier hostList=new ArrayList();
hostList.add("h1");
hostList.add("h2");
hostList.add("h3");
addServiceComponent(c1,hostList,"ZOOKEEPER","ZOOKEEPER_CLIENT");
Set changedHosts=new HashSet();
changedHosts.add("h1");
changedHosts.add("h2");
changedHosts.add("h3");
assertRepoVersionState(stackId.getStackId(),INSTALLED_VERSION,RepositoryVersionState.INSTALLED);
List hostVersions=hostVersionDAO.findAll();
for ( HostVersionEntity hostVersionEntity : hostVersions) {
RepositoryVersionEntity repoVersion=hostVersionEntity.getRepositoryVersion();
if (repoVersion.getVersion().equals(INSTALLED_VERSION) || repoVersion.getVersion().equals(INSTALLED_VERSION_2)) {
if (changedHosts.contains(hostVersionEntity.getHostName())) {
assertEquals(hostVersionEntity.getState(),RepositoryVersionState.OUT_OF_SYNC);
}
else {
assertEquals(hostVersionEntity.getState(),RepositoryVersionState.INSTALLED);
}
}
}
}
BranchVerifier InternalCallVerifier EqualityVerifier hostList=new ArrayList();
hostList.add("h1");
hostList.add("h2");
hostList.add("h3");
Map> hdfsTopology=new HashMap>();
hdfsTopology.put("GANGLIA_SERVER",Collections.singletonList(0));
List monitorHosts=Arrays.asList(0,1);
hdfsTopology.put("GANGLIA_MONITOR",new ArrayList(monitorHosts));
addService(c1,hostList,hdfsTopology,"GANGLIA");
Set changedHosts=new HashSet();
changedHosts.add("h1");
changedHosts.add("h2");
List hostVersions=hostVersionDAO.findAll();
assertRepoVersionState(stackId.getStackId(),INSTALLED_VERSION,RepositoryVersionState.INSTALLED);
for ( HostVersionEntity hostVersionEntity : hostVersions) {
if (hostVersionEntity.getRepositoryVersion().getVersion().equals(INSTALLED_VERSION)) {
assertEquals(hostVersionEntity.getState(),RepositoryVersionState.INSTALLED);
}
}
}
Class: org.apache.ambari.server.events.publishers.VersionEventPublisherTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.metadata.AgentAlertDefinitionsTest InternalCallVerifier EqualityVerifier definitions=ambariServiceAlertDefinitions.getAgentDefinitions();
Assert.assertEquals(1,definitions.size());
for ( AlertDefinition definition : definitions) {
Assert.assertEquals(Components.AMBARI_AGENT.name(),definition.getComponentName());
Assert.assertEquals("AMBARI",definition.getServiceName());
}
}
InternalCallVerifier EqualityVerifier definitions=ambariServiceAlertDefinitions.getServerDefinitions();
Assert.assertEquals(2,definitions.size());
for ( AlertDefinition definition : definitions) {
Assert.assertEquals(Components.AMBARI_SERVER.name(),definition.getComponentName());
Assert.assertEquals("AMBARI",definition.getServiceName());
}
}
Class: org.apache.ambari.server.metadata.RoleCommandOrderTest APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier testData=mapper.readValue(testJsonIS,new TypeReference>(){
}
);
rco.addDependencies(testData);
mapper.setVisibility(JsonMethod.ALL,JsonAutoDetect.Visibility.ANY);
String dump=mapper.writeValueAsString(rco.getDependencies());
List parts=Arrays.asList(dump.substring(1,522).split(Pattern.quote("],")));
assertEquals(3,parts.size());
assertTrue(parts.contains("\"RoleCommandPair{role=SECONDARY_NAMENODE, cmd=UPGRADE}\":[{\"role\":{\"name\":\"NAMENODE\"},\"cmd\":\"UPGRADE\"}"));
assertTrue(parts.contains("\"RoleCommandPair{role=SECONDARY_NAMENODE, cmd=START}\":[{\"role\":{\"name\":\"NAMENODE\"},\"cmd\":\"START\"}"));
boolean datanodeCommandExists=false;
for ( String part : parts) {
if (part.contains("RoleCommandPair{role=DATANODE, cmd=STOP}")) {
datanodeCommandExists=true;
String[] parts2=part.split(Pattern.quote(":["));
assertEquals(2,parts2.length);
assertEquals("\"RoleCommandPair{role=DATANODE, cmd=STOP}\"",parts2[0]);
List components=Arrays.asList(new String[]{"\"role\":{\"name\":\"HBASE_MASTER\"},\"cmd\":\"STOP\"","\"role\":{\"name\":\"RESOURCEMANAGER\"},\"cmd\":\"STOP\"","\"role\":{\"name\":\"TASKTRACKER\"},\"cmd\":\"STOP\"","\"role\":{\"name\":\"NODEMANAGER\"},\"cmd\":\"STOP\"","\"role\":{\"name\":\"HISTORYSERVER\"},\"cmd\":\"STOP\"","\"role\":{\"name\":\"JOBTRACKER\"},\"cmd\":\"STOP\""});
Assert.assertTrue(CollectionPresentationUtils.isStringPermutationOfCollection(parts2[1],components,"},{",1,1));
}
}
assertTrue(datanodeCommandExists);
}
InternalCallVerifier BooleanVerifier > deps=rco.getDependencies();
assertTrue("Dependencies are empty before initialization",deps.size() == 0);
rco.initialize(cluster);
assertTrue("Dependencies are loaded after initialization",deps.size() > 0);
verify(cluster);
verify(hdfsService);
assertFalse(dependenciesContainBlockedRole(deps,Role.PEERSTATUS));
assertFalse(dependenciesContainBlockedRole(deps,Role.GLUSTERFS_SERVICE_CHECK));
assertFalse(dependenciesContainBlockedRole(deps,Role.GLUSTERFS_CLIENT));
assertFalse(dependenciesContainBlockerRole(deps,Role.PEERSTATUS));
assertFalse(dependenciesContainBlockerRole(deps,Role.GLUSTERFS_SERVICE_CHECK));
assertFalse(dependenciesContainBlockerRole(deps,Role.GLUSTERFS_CLIENT));
assertTrue(dependenciesContainBlockerRole(deps,Role.DATANODE));
assertTrue(dependenciesContainBlockerRole(deps,Role.JOURNALNODE));
assertTrue(dependenciesContainBlockedRole(deps,Role.ZKFC));
}
InternalCallVerifier BooleanVerifier > deps=rco.getDependencies();
assertTrue("Dependencies are empty before initialization",deps.size() == 0);
rco.initialize(cluster);
assertTrue("Dependencies are loaded after initialization",deps.size() > 0);
verify(cluster);
verify(hdfsService);
assertFalse(dependenciesContainBlockedRole(deps,Role.PEERSTATUS));
assertFalse(dependenciesContainBlockedRole(deps,Role.GLUSTERFS_SERVICE_CHECK));
assertFalse(dependenciesContainBlockedRole(deps,Role.GLUSTERFS_CLIENT));
assertFalse(dependenciesContainBlockerRole(deps,Role.PEERSTATUS));
assertFalse(dependenciesContainBlockerRole(deps,Role.GLUSTERFS_SERVICE_CHECK));
assertFalse(dependenciesContainBlockerRole(deps,Role.GLUSTERFS_CLIENT));
assertTrue(dependenciesContainBlockerRole(deps,Role.DATANODE));
assertFalse(dependenciesContainBlockerRole(deps,Role.JOURNALNODE));
assertFalse(dependenciesContainBlockedRole(deps,Role.ZKFC));
}
InternalCallVerifier BooleanVerifier > deps=rco.getDependencies();
assertTrue("Dependencies are empty before initialization",deps.size() == 0);
rco.initialize(cluster);
assertTrue("Dependencies are loaded after initialization",deps.size() > 0);
verify(cluster);
assertFalse(dependenciesContainBlockedRole(deps,Role.DATANODE));
assertFalse(dependenciesContainBlockedRole(deps,Role.NAMENODE));
assertFalse(dependenciesContainBlockedRole(deps,Role.SECONDARY_NAMENODE));
assertFalse(dependenciesContainBlockedRole(deps,Role.JOURNALNODE));
assertFalse(dependenciesContainBlockedRole(deps,Role.NAMENODE_SERVICE_CHECK));
assertFalse(dependenciesContainBlockedRole(deps,Role.HDFS_SERVICE_CHECK));
assertFalse(dependenciesContainBlockedRole(deps,Role.HDFS_CLIENT));
assertFalse(dependenciesContainBlockerRole(deps,Role.SECONDARY_NAMENODE));
assertFalse(dependenciesContainBlockerRole(deps,Role.JOURNALNODE));
assertFalse(dependenciesContainBlockerRole(deps,Role.NAMENODE_SERVICE_CHECK));
assertFalse(dependenciesContainBlockerRole(deps,Role.HDFS_SERVICE_CHECK));
assertFalse(dependenciesContainBlockerRole(deps,Role.HDFS_CLIENT));
assertTrue(dependenciesContainBlockerRole(deps,Role.PEERSTATUS));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier hdfsComponents=Collections.singletonMap("NAMENODE",namenode);
expect(hdfsService.getServiceComponents()).andReturn(hdfsComponents).anyTimes();
Service hbaseService=createMock(Service.class);
expect(cluster.getService("HBASE")).andReturn(hbaseService).atLeastOnce();
expect(hbaseService.getCluster()).andReturn(cluster).anyTimes();
ServiceComponent hbaseMaster=createMock(ServiceComponent.class);
expect(hbaseMaster.getName()).andReturn("HBASE_MASTER").anyTimes();
Map hbaseComponents=Collections.singletonMap("HBASE_MASTER",hbaseMaster);
expect(hbaseService.getServiceComponents()).andReturn(hbaseComponents).anyTimes();
Map installedServices=new HashMap();
installedServices.put("HDFS",hdfsService);
installedServices.put("HBASE",hbaseService);
expect(cluster.getServices()).andReturn(installedServices).atLeastOnce();
expect(cluster.getService("HDFS")).andReturn(hdfsService).atLeastOnce();
expect(cluster.getService("GLUSTERFS")).andReturn(null);
expect(cluster.getService("YARN")).andReturn(null);
expect(hdfsService.getServiceComponent("JOURNALNODE")).andReturn(null);
expect(cluster.getCurrentStackVersion()).andReturn(new StackId("HDP","2.0.5"));
replay(cluster,hdfsService,hbaseService,hbaseMaster,namenode);
rco.initialize(cluster);
Set transitiveServices=rco.getTransitiveServices(cluster.getService("HBASE"),RoleCommand.START);
Assert.assertNotNull(transitiveServices);
Assert.assertFalse(transitiveServices.isEmpty());
Assert.assertEquals(1,transitiveServices.size());
Assert.assertTrue(transitiveServices.contains(hdfsService));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier hostComponents=new HashMap();
hostComponents.put("1",sch1);
hostComponents.put("2",sch2);
Service yarnService=createMock(Service.class);
ServiceComponent resourcemanagerSC=createMock(ServiceComponent.class);
expect(cluster.getService("YARN")).andReturn(yarnService).atLeastOnce();
expect(cluster.getService("HDFS")).andReturn(null);
expect(yarnService.getServiceComponent("RESOURCEMANAGER")).andReturn(resourcemanagerSC).anyTimes();
expect(resourcemanagerSC.getServiceComponentHosts()).andReturn(hostComponents).anyTimes();
expect(cluster.getCurrentStackVersion()).andReturn(new StackId("HDP","2.0.6"));
replay(cluster,yarnService,sch1,sch2,resourcemanagerSC);
Map> deps=rco.getDependencies();
assertTrue("Dependencies are empty before initialization",deps.size() == 0);
rco.initialize(cluster);
assertTrue("Dependencies are loaded after initialization",deps.size() > 0);
verify(cluster,yarnService);
assertFalse(dependenciesContainBlockedRole(deps,Role.PEERSTATUS));
assertFalse(dependenciesContainBlockedRole(deps,Role.GLUSTERFS_SERVICE_CHECK));
assertFalse(dependenciesContainBlockedRole(deps,Role.GLUSTERFS_CLIENT));
assertFalse(dependenciesContainBlockerRole(deps,Role.PEERSTATUS));
assertFalse(dependenciesContainBlockerRole(deps,Role.GLUSTERFS_SERVICE_CHECK));
assertFalse(dependenciesContainBlockerRole(deps,Role.GLUSTERFS_CLIENT));
assertTrue(dependenciesContainBlockerRole(deps,Role.DATANODE));
RoleCommandPair rmPair=new RoleCommandPair(Role.RESOURCEMANAGER,RoleCommand.START);
Set rmRoleCommandPairs=deps.get(rmPair);
assertNotNull(rmRoleCommandPairs);
boolean isZookeeperStartPresent=false;
for ( RoleCommandPair pair : rmRoleCommandPairs) {
if (pair.cmd == RoleCommand.START && pair.getRole() == Role.ZOOKEEPER_SERVER) {
isZookeeperStartPresent=true;
}
}
assertTrue(isZookeeperStartPresent);
}
Class: org.apache.ambari.server.metadata.RoleGraphTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.notifications.DispatchFactoryTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.notifications.dispatchers.EmailDispatcherTest InternalCallVerifier EqualityVerifier properties=new HashMap();
Transport mockedTransport=EasyMock.createNiceMock(Transport.class);
EmailDispatcher dispatcher=EasyMock.createMockBuilder(EmailDispatcher.class).addMockedMethods("getMailTransport").createNiceMock();
EasyMock.expect(dispatcher.getMailTransport(properties)).andReturn(mockedTransport);
EasyMock.replay(dispatcher,mockedTransport);
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
Assert.assertEquals(TargetConfigurationResult.Status.VALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
Transport mockedTransport=EasyMock.createNiceMock(Transport.class);
EmailDispatcher dispatcher=EasyMock.createMockBuilder(EmailDispatcher.class).addMockedMethods("getMailTransport").createNiceMock();
EasyMock.expect(dispatcher.getMailTransport(properties)).andReturn(mockedTransport);
mockedTransport.connect();
EasyMock.expectLastCall().andThrow(new MessagingException());
EasyMock.replay(dispatcher,mockedTransport);
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
Assert.assertEquals(TargetConfigurationResult.Status.INVALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
Transport mockedTransport=EasyMock.createNiceMock(Transport.class);
EmailDispatcher dispatcher=EasyMock.createMockBuilder(EmailDispatcher.class).addMockedMethods("getMailTransport").createNiceMock();
EasyMock.expect(dispatcher.getMailTransport(properties)).andReturn(mockedTransport);
mockedTransport.connect();
EasyMock.expectLastCall().andThrow(new AuthenticationFailedException());
EasyMock.replay(dispatcher,mockedTransport);
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
Assert.assertEquals(TargetConfigurationResult.Status.INVALID,configValidationResult.getStatus());
}
Class: org.apache.ambari.server.notifications.dispatchers.SNMPDispatcherTest InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv3");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SECURITY_USERNAME_PROPERTY,"USER");
properties.put(SNMPDispatcher.SECURITY_AUTH_PASSPHRASE_PROPERTY,"PASSPHRASE1");
properties.put(SNMPDispatcher.SECURITY_PRIV_PASSPHRASE_PROPERTY,"PASSPHRASE2");
properties.put(SNMPDispatcher.SECURITY_LEVEL_PROPERTY,"AUTH_PRIV");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.VALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv3");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SECURITY_USERNAME_PROPERTY,"USER");
properties.put(SNMPDispatcher.SECURITY_AUTH_PASSPHRASE_PROPERTY,"PASSPHRASE1");
properties.put(SNMPDispatcher.SECURITY_LEVEL_PROPERTY,"AUTH_PRIV");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.INVALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv1");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.COMMUNITY_PROPERTY,"public");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.VALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv4");
properties.put(SNMPDispatcher.COMMUNITY_PROPERTY,"public");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.INVALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.COMMUNITY_PROPERTY,"public");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
notification.DispatchProperties=properties;
Recipient rec1=new Recipient();
rec1.Identifier="192.168.0.2";
notification.Recipients=Arrays.asList(rec1);
doReturn(trap).when(dispatcher).prepareTrap(notification,snmpVersion);
dispatcher.sendTraps(notification,snmpVersion);
ArgumentCaptor argument=ArgumentCaptor.forClass(Target.class);
verify(snmp,times(1)).send(eq(trap),argument.capture());
assertEquals("192.168.0.2/162",argument.getValue().getAddress().toString());
assertEquals(SnmpConstants.version2c,argument.getValue().getVersion());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv2c");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.COMMUNITY_PROPERTY,"public");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.VALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv3");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SECURITY_USERNAME_PROPERTY,"USER");
properties.put(SNMPDispatcher.SECURITY_AUTH_PASSPHRASE_PROPERTY,"PASSPHRASE1");
properties.put(SNMPDispatcher.SECURITY_PRIV_PASSPHRASE_PROPERTY,"PASSPHRASE2");
properties.put(SNMPDispatcher.SECURITY_LEVEL_PROPERTY,"AUTH_NOPRIV");
notification.DispatchProperties=properties;
Recipient rec1=new Recipient();
rec1.Identifier="192.168.0.2";
notification.Recipients=Arrays.asList(rec1);
doReturn(trap).when(dispatcher).prepareTrap(notification,snmpVersion);
dispatcher.sendTraps(notification,snmpVersion);
ArgumentCaptor argument=ArgumentCaptor.forClass(Target.class);
verify(snmp,times(1)).send(eq(trap),argument.capture());
assertEquals("192.168.0.2/162",argument.getValue().getAddress().toString());
assertEquals(SnmpConstants.version3,argument.getValue().getVersion());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv3");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SECURITY_USERNAME_PROPERTY,"USER");
properties.put(SNMPDispatcher.SECURITY_LEVEL_PROPERTY,"AUTH_PRIV");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.INVALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv2c");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.INVALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv1");
properties.put(SNMPDispatcher.COMMUNITY_PROPERTY,"public");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.INVALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.COMMUNITY_PROPERTY,"public");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
notification.DispatchProperties=properties;
Recipient rec1=new Recipient();
rec1.Identifier="192.168.0.2";
notification.Recipients=Arrays.asList(rec1);
doReturn(trap).when(dispatcher).prepareTrap(notification,snmpVersion);
dispatcher.sendTraps(notification,snmpVersion);
ArgumentCaptor argument=ArgumentCaptor.forClass(Target.class);
verify(snmp,times(1)).send(eq(trap),argument.capture());
assertEquals("192.168.0.2/162",argument.getValue().getAddress().toString());
assertEquals(SnmpConstants.version1,argument.getValue().getVersion());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"3");
notification.DispatchProperties=properties;
notification.Body="body";
notification.Subject="subject";
PDU pdu=dispatcher.prepareTrap(notification,snmpVersion);
assertEquals(PDU.V1TRAP,pdu.getType());
Map variableBindings=new HashMap();
for ( VariableBinding variableBinding : pdu.toArray()) {
variableBindings.put(variableBinding.getOid().toString(),variableBinding);
}
assertEquals(3,variableBindings.size());
assertEquals("subject",variableBindings.get("1").toValueString());
assertEquals("body",variableBindings.get("2").toValueString());
assertEquals("3",variableBindings.get(SnmpConstants.snmpTrapOID.toString()).toValueString());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv3");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SECURITY_USERNAME_PROPERTY,"USER");
properties.put(SNMPDispatcher.SECURITY_LEVEL_PROPERTY,"AUTH_NOPRIV");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.INVALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv3");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SECURITY_USERNAME_PROPERTY,"USER");
properties.put(SNMPDispatcher.SECURITY_AUTH_PASSPHRASE_PROPERTY,"PASSPHRASE1");
properties.put(SNMPDispatcher.SECURITY_PRIV_PASSPHRASE_PROPERTY,"PASSPHRASE2");
properties.put(SNMPDispatcher.SECURITY_LEVEL_PROPERTY,"INCORRECT");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.INVALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv3");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SECURITY_USERNAME_PROPERTY,"USER");
properties.put(SNMPDispatcher.SECURITY_LEVEL_PROPERTY,"NOAUTH_NOPRIV");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.VALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.PORT_PROPERTY,"162");
properties.put(SNMPDispatcher.SNMP_VERSION_PROPERTY,"SNMPv3");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"1.3.6.1.6.3.1.1.5.4");
properties.put(SNMPDispatcher.SECURITY_USERNAME_PROPERTY,"USER");
properties.put(SNMPDispatcher.SECURITY_AUTH_PASSPHRASE_PROPERTY,"PASSPHRASE1");
properties.put(SNMPDispatcher.SECURITY_LEVEL_PROPERTY,"AUTH_NOPRIV");
NotificationDispatcher dispatcher=new SNMPDispatcher();
TargetConfigurationResult configValidationResult=dispatcher.validateTargetConfig(properties);
assertEquals(TargetConfigurationResult.Status.VALID,configValidationResult.getStatus());
}
InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put(SNMPDispatcher.SUBJECT_OID_PROPERTY,"1");
properties.put(SNMPDispatcher.BODY_OID_PROPERTY,"2");
properties.put(SNMPDispatcher.TRAP_OID_PROPERTY,"4");
notification.DispatchProperties=properties;
notification.Body="body";
notification.Subject="subject";
PDU pdu=dispatcher.prepareTrap(notification,snmpVersion);
assertEquals(PDU.TRAP,pdu.getType());
Map variableBindings=new HashMap();
for ( VariableBinding variableBinding : pdu.toArray()) {
variableBindings.put(variableBinding.getOid().toString(),variableBinding);
}
assertEquals(3,variableBindings.size());
assertEquals("subject",variableBindings.get("1").toValueString());
assertEquals("body",variableBindings.get("2").toValueString());
assertEquals("4",variableBindings.get(SnmpConstants.snmpTrapOID.toString()).toValueString());
}
Class: org.apache.ambari.server.orm.DBAccessorImplTest APIUtilityVerifier IterativeVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier IterativeVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier columns=new ArrayList();
columns.add(new DBColumnInfo("fid",Long.class,null,null,false));
columns.add(new DBColumnInfo("fname",String.class,null,null,false));
String foreignTableName=getFreeTableName();
dbAccessor.createTable(foreignTableName,columns,"fid");
Statement statement=dbAccessor.getConnection().createStatement();
statement.execute("ALTER TABLE " + foreignTableName + " ADD CONSTRAINT FK_test FOREIGN KEY (fid) REFERENCES "+ tableName+ " (id)");
Assert.assertTrue(dbAccessor.tableHasForeignKey(foreignTableName,tableName,"fid","id"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier IterativeVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier columns=new ArrayList();
columns.add(new DBColumnInfo("fid",Long.class,null,null,false));
columns.add(new DBColumnInfo("fname",String.class,null,null,false));
String foreignTableName=getFreeTableName();
dbAccessor.createTable(foreignTableName,columns,"fid");
Statement statement=dbAccessor.getConnection().createStatement();
statement.execute("ALTER TABLE " + foreignTableName + " ADD CONSTRAINT FK_test1 FOREIGN KEY (fid) REFERENCES "+ tableName+ " (id)");
Assert.assertEquals("FK_TEST1",dbAccessor.getCheckedForeignKey(foreignTableName,"fk_test1"));
}
APIUtilityVerifier IterativeVerifier InternalCallVerifier EqualityVerifier columns=new ArrayList();
columns.add(new DBColumnInfo("fid",Long.class,null,null,false));
columns.add(new DBColumnInfo("fname",String.class,null,null,false));
String foreignTableName=getFreeTableName();
dbAccessor.createTable(foreignTableName,columns,"fid");
dbAccessor.addFKConstraint(foreignTableName,"MYFKCONSTRAINT","fid",tableName,"id",false);
Statement statement=dbAccessor.getConnection().createStatement();
statement.execute("insert into " + tableName + "(id, name) values(1,'hello')");
statement.execute("insert into " + foreignTableName + "(fid, fname) values(1,'howdy')");
ResultSet resultSet=statement.executeQuery("select * from " + foreignTableName);
int count=0;
while (resultSet.next()) {
assertEquals(resultSet.getString("fname"),"howdy");
count++;
}
resultSet.close();
assertEquals(count,1);
exception.expect(SQLException.class);
exception.expectMessage(containsString("MYFKCONSTRAINT"));
dbAccessor.dropTable(tableName);
}
APIUtilityVerifier IterativeVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier IterativeVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier IterativeVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.TestOrmImpl InternalCallVerifier BooleanVerifier list=hostRoleCommandDAO.findSortedCommandsByStageAndHost(stageDAO.findByActionId("1-1"),hostDAO.findByName("test_host1"));
log.info("command '{}' - taskId '{}' ",list.get(0).getRoleCommand(),list.get(0).getTaskId());
log.info("command '{}' - taskId '{}'",list.get(1).getRoleCommand(),list.get(1).getTaskId());
assertTrue(list.get(0).getTaskId() < list.get(1).getTaskId());
}
InternalCallVerifier EqualityVerifier hosts=hostDAO.findByStage(stageEntity);
assertEquals(2,hosts.size());
}
InternalCallVerifier NullVerifier InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier stageEntities=new ArrayList();
StageEntity stageEntity=new StageEntity();
stageEntity.setClusterId(clusterDAO.findByName("test_cluster1").getClusterId());
stageEntity.setRequest(requestEntity);
stageEntity.setStageId(2L);
stageDAO.create(stageEntity);
StageEntity stageEntity2=new StageEntity();
stageEntity2.setClusterId(clusterDAO.findByName("test_cluster1").getClusterId());
stageEntity2.setRequest(requestEntity);
stageEntity2.setRequestId(1L);
stageEntity2.setStageId(3L);
stageDAO.create(stageEntity2);
stageEntities.add(stageEntity);
stageEntities.add(stageEntity2);
requestEntity.setStages(stageEntities);
requestDAO.merge(requestEntity);
assertEquals(1L,stageDAO.getLastRequestId());
}
InternalCallVerifier EqualityVerifier list=hostRoleCommandDAO.findByHostRole("test_host1",1L,1L,Role.DATANODE.toString());
assertEquals(1,list.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier result=clusterDAO.findAll();
final ResourceTypeEntity finalResourceTypeEntity=resourceTypeEntity;
thread=new Thread(){
@Override public void run(){
ResourceEntity resourceEntity=new ResourceEntity();
resourceEntity.setResourceType(finalResourceTypeEntity);
ClusterEntity temp=new ClusterEntity();
temp.setClusterName("temp_cluster");
temp.setResource(resourceEntity);
temp.setDesiredStack(stackEntity);
clusterDAO.create(temp);
}
}
;
thread.start();
thread.join();
assertEquals(result.size() + 1,(result=clusterDAO.findAll()).size());
thread=new Thread(){
@Override public void run(){
ResourceEntity resourceEntity=new ResourceEntity();
resourceEntity.setResourceType(finalResourceTypeEntity);
ClusterEntity temp=new ClusterEntity();
temp.setClusterName("temp_cluster2");
temp.setResource(resourceEntity);
temp.setDesiredStack(stackEntity);
clusterDAO.create(temp);
}
}
;
thread.start();
thread.join();
assertEquals(result.size() + 1,(clusterDAO.findAll()).size());
}
InternalCallVerifier NullVerifier InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.orm.dao.AlertDefinitionDAOTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier definitions=dao.findAll();
List ids=new ArrayList();
ids.add(definitions.get(0).getDefinitionId());
ids.add(definitions.get(1).getDefinitionId());
ids.add(99999L);
definitions=dao.findByIds(ids);
assertEquals(2,definitions.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=dao.findAll();
assertNotNull(definitions);
AlertDefinitionEntity definition=definitions.get(2);
AlertDefinitionEntity retrieved=dao.findById(definition.getDefinitionId());
assertEquals(definition,retrieved);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=dao.findByService(clusterId,"HDFS");
assertNotNull(definitions);
assertEquals(10,definitions.size());
definitions=dao.findByService(clusterId,"YARN");
assertNotNull(definitions);
assertEquals(0,definitions.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=dao.findByServiceComponent(clusterId,"OOZIE","OOZIE_SERVER");
assertNotNull(definitions);
assertEquals(2,definitions.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=dao.findAll();
assertNotNull(definitions);
AlertDefinitionEntity definition=definitions.get(2);
AlertDefinitionEntity retrieved=dao.findByName(definition.getClusterId(),definition.getDefinitionName());
assertEquals(definition,retrieved);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=dao.findAll();
assertNotNull(definitions);
assertEquals(15,definitions.size());
List enabledDefinitions=dao.findAllEnabled(clusterId);
assertNotNull(enabledDefinitions);
assertEquals(definitions.size(),enabledDefinitions.size());
enabledDefinitions.get(0).setEnabled(false);
dao.merge(enabledDefinitions.get(0));
enabledDefinitions=dao.findAllEnabled(clusterId);
assertNotNull(enabledDefinitions);
assertEquals(definitions.size() - 1,enabledDefinitions.size());
}
InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=dao.findAgentScoped(clusterId);
assertNotNull(definitions);
assertEquals(3,definitions.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=dao.findAll();
assertNotNull(definitions);
assertEquals(15,definitions.size());
}
Class: org.apache.ambari.server.orm.dao.AlertDispatchDAOTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier targets=m_dao.findAllTargets();
assertNotNull(targets);
assertEquals(5,targets.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=createDefinitions();
AlertGroupEntity group=m_helper.createAlertGroup(m_cluster.getClusterId(),null);
group=m_dao.findGroupById(group.getGroupId());
assertNotNull(group);
for ( AlertDefinitionEntity definition : definitions) {
group.addAlertDefinition(definition);
}
m_dao.merge(group);
group=m_dao.findGroupByName(group.getGroupName());
assertEquals(definitions.size(),group.getAlertDefinitions().size());
for ( AlertDefinitionEntity definition : definitions) {
List groups=m_dao.findGroupsByDefinition(definition);
assertEquals(2,groups.size());
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier groups=m_dao.findAllGroups();
assertNotNull(groups);
assertEquals(10,groups.size());
for ( AlertGroupEntity group : groups) {
assertFalse(group.isDefault());
}
Cluster cluster=m_helper.buildNewCluster(m_clusters,m_serviceFactory,m_componentFactory,m_schFactory,HOSTNAME);
AlertGroupEntity hdfsGroup=m_dao.findDefaultServiceGroup(cluster.getClusterId(),"HDFS");
m_dao.remove(hdfsGroup);
hdfsGroup=m_dao.findDefaultServiceGroup(cluster.getClusterId(),"HDFS");
assertNull(hdfsGroup);
AlertDefinitionEntity datanodeProcess=new AlertDefinitionEntity();
datanodeProcess.setClusterId(cluster.getClusterId());
datanodeProcess.setDefinitionName("datanode_process");
datanodeProcess.setServiceName("HDFS");
datanodeProcess.setComponentName("DATANODE");
datanodeProcess.setHash(UUID.randomUUID().toString());
datanodeProcess.setScheduleInterval(60);
datanodeProcess.setScope(Scope.SERVICE);
datanodeProcess.setSource("{\"type\" : \"SCRIPT\"}");
datanodeProcess.setSourceType(SourceType.SCRIPT);
m_definitionDao.create(datanodeProcess);
hdfsGroup=m_dao.findDefaultServiceGroup(cluster.getClusterId(),"HDFS");
assertNotNull(hdfsGroup);
assertTrue(hdfsGroup.isDefault());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier targets=m_dao.findAllGlobalTargets();
assertNotNull(targets);
assertEquals(0,targets.size());
m_helper.createGlobalAlertTarget();
m_helper.createGlobalAlertTarget();
m_helper.createGlobalAlertTarget();
targets=m_dao.findAllGlobalTargets();
assertEquals(3,targets.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier groups=m_dao.findAllGroups();
target=m_dao.findTargetById(target.getTargetId());
assertEquals(groups.size(),target.getAlertGroups().size());
m_dao.remove(target);
group=m_dao.findGroupById(group.getGroupId());
assertNotNull(group);
assertEquals(0,group.getAlertTargets().size());
}
InternalCallVerifier EqualityVerifier notices=m_dao.findAllNotices(request);
assertEquals(3,notices.size());
request.Pagination=new PageRequestImpl(StartingPoint.Beginning,2,0,null,null);
notices=m_dao.findAllNotices(request);
assertEquals(2,notices.size());
request.Pagination=new PageRequestImpl(StartingPoint.Beginning,1,2,null,null);
notices=m_dao.findAllNotices(request);
assertEquals(1,notices.size());
request.Pagination=new PageRequestImpl(StartingPoint.Beginning,1,3,null,null);
notices=m_dao.findAllNotices(request);
assertEquals(0,notices.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=createDefinitions();
AlertDefinitionEntity definition=definitions.get(0);
AlertHistoryEntity history=new AlertHistoryEntity();
history.setServiceName(definition.getServiceName());
history.setClusterId(m_cluster.getClusterId());
history.setAlertDefinition(definition);
history.setAlertLabel("Label");
history.setAlertState(AlertState.OK);
history.setAlertText("Alert Text");
history.setAlertTimestamp(System.currentTimeMillis());
m_alertsDao.create(history);
AlertTargetEntity target=m_helper.createAlertTarget();
AlertNoticeEntity notice=new AlertNoticeEntity();
notice.setUuid(UUID.randomUUID().toString());
notice.setAlertTarget(target);
notice.setAlertHistory(history);
notice.setNotifyState(NotificationState.PENDING);
m_dao.create(notice);
AlertNoticeEntity actual=m_dao.findNoticeByUuid(notice.getUuid());
assertEquals(notice.getNotificationId(),actual.getNotificationId());
assertNull(m_dao.findNoticeByUuid("DEADBEEF"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier groups=m_dao.findAllGroups();
assertNotNull(groups);
assertEquals(10,groups.size());
for ( AlertGroupEntity group : groups) {
assertFalse(group.isDefault());
}
Cluster cluster=m_helper.buildNewCluster(m_clusters,m_serviceFactory,m_componentFactory,m_schFactory,HOSTNAME);
AlertGroupEntity hdfsGroup=m_dao.findDefaultServiceGroup(cluster.getClusterId(),"HDFS");
assertNotNull(hdfsGroup);
assertTrue(hdfsGroup.isDefault());
}
InternalCallVerifier EqualityVerifier notices=m_dao.findAllNotices(request);
assertEquals(3,notices.size());
request.Predicate=hdfsPredicate;
notices=m_dao.findAllNotices(request);
assertEquals(2,notices.size());
request.Predicate=yarnPredicate;
notices=m_dao.findAllNotices(request);
assertEquals(1,notices.size());
request.Predicate=adminPredicate;
notices=m_dao.findAllNotices(request);
assertEquals(2,notices.size());
request.Predicate=adminOrOperatorPredicate;
notices=m_dao.findAllNotices(request);
assertEquals(3,notices.size());
request.Predicate=pendingPredicate;
notices=m_dao.findAllNotices(request);
assertEquals(1,notices.size());
noticeIdPredicate=new PredicateBuilder().property(AlertNoticeResourceProvider.ALERT_NOTICE_ID).equals(notices.get(0).getNotificationId()).toPredicate();
request.Predicate=noticeIdPredicate;
notices=m_dao.findAllNotices(request);
assertEquals(1,notices.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier iterator=group.getAlertTargets().iterator();
AlertTargetEntity groupTarget1=iterator.next();
AlertTargetEntity groupTarget2=iterator.next();
assertTrue(groupTarget1.isGlobal());
assertTrue(groupTarget2.isGlobal());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier sortProperties=new ArrayList();
SortRequest sortRequest=new SortRequestImpl(sortProperties);
AlertNoticeRequest request=new AlertNoticeRequest();
request.Sort=sortRequest;
Predicate clusterPredicate=new PredicateBuilder().property(AlertNoticeResourceProvider.ALERT_NOTICE_CLUSTER_NAME).equals("c1").toPredicate();
request.Predicate=clusterPredicate;
sortProperties.add(new SortRequestProperty(AlertNoticeResourceProvider.ALERT_NOTICE_ID,Order.ASC));
List notices=m_dao.findAllNotices(request);
assertEquals(3,notices.size());
long lastId=0L;
for ( AlertNoticeEntity notice : notices) {
if (lastId == 0L) {
lastId=notice.getNotificationId();
continue;
}
long currentId=notice.getNotificationId();
assertTrue(lastId < currentId);
lastId=currentId;
}
sortProperties.clear();
sortProperties.add(new SortRequestProperty(AlertNoticeResourceProvider.ALERT_NOTICE_ID,Order.DESC));
notices=m_dao.findAllNotices(request);
assertEquals(3,notices.size());
lastId=0L;
for ( AlertNoticeEntity notice : notices) {
if (lastId == 0L) {
lastId=notice.getNotificationId();
continue;
}
long currentId=notice.getNotificationId();
assertTrue(lastId > currentId);
lastId=currentId;
}
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier targets=new HashSet();
targets.add(target);
AlertGroupEntity group=m_helper.createAlertGroup(m_cluster.getClusterId(),targets);
assertEquals(1,group.getAlertTargets().size());
target=m_dao.findTargetById(target.getTargetId());
m_dao.refresh(target);
assertNotNull(target);
assertEquals(1,target.getAlertGroups().size());
m_dao.remove(target);
target=m_dao.findTargetById(target.getTargetId());
assertNull(target);
group=m_dao.findGroupById(group.getGroupId());
assertNotNull(group);
assertEquals(0,group.getAlertTargets().size());
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier groups=m_dao.findAllGroups();
assertNotNull(groups);
assertEquals(10,groups.size());
List ids=new ArrayList();
ids.add(groups.get(0).getGroupId());
ids.add(groups.get(1).getGroupId());
ids.add(99999L);
groups=m_dao.findGroupsById(ids);
assertEquals(2,groups.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=createDefinitions();
AlertDefinitionEntity definition=definitions.get(0);
AlertHistoryEntity history=new AlertHistoryEntity();
history.setServiceName(definition.getServiceName());
history.setClusterId(m_cluster.getClusterId());
history.setAlertDefinition(definition);
history.setAlertLabel("Label");
history.setAlertState(AlertState.OK);
history.setAlertText("Alert Text");
history.setAlertTimestamp(System.currentTimeMillis());
m_alertsDao.create(history);
AlertNoticeEntity notice=new AlertNoticeEntity();
notice.setUuid(UUID.randomUUID().toString());
notice.setAlertTarget(target);
notice.setAlertHistory(history);
notice.setNotifyState(NotificationState.PENDING);
m_dao.create(notice);
notice=m_dao.findNoticeById(notice.getNotificationId());
assertEquals(target.getTargetId(),notice.getAlertTarget().getTargetId());
target=m_dao.findTargetById(target.getTargetId());
m_dao.remove(target);
notice=m_dao.findNoticeById(notice.getNotificationId());
assertNull(notice);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier targets=m_dao.findAllTargets();
assertNotNull(targets);
AlertTargetEntity target=targets.get(3);
AlertTargetEntity actual=m_dao.findTargetByName(target.getTargetName());
assertEquals(target,actual);
}
InternalCallVerifier EqualityVerifier targets=new HashSet();
targets.add(target);
String groupName="Group Name " + System.currentTimeMillis();
AlertGroupEntity group=m_helper.createAlertGroup(m_cluster.getClusterId(),null);
group=m_dao.findGroupById(group.getGroupId());
group.setGroupName(groupName + "FOO");
group.setDefault(true);
m_dao.merge(group);
group=m_dao.findGroupById(group.getGroupId());
assertEquals(groupName + "FOO",group.getGroupName());
assertEquals(true,group.isDefault());
assertEquals(0,group.getAlertDefinitions().size());
assertEquals(0,group.getAlertTargets().size());
group.addAlertTarget(target);
m_dao.merge(group);
group=m_dao.findGroupById(group.getGroupId());
assertEquals(targets,group.getAlertTargets());
}
InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier ExceptionVerifier HybridVerifier groups=m_dao.findAllGroups();
assertNotNull(groups);
assertEquals(10,groups.size());
for ( AlertGroupEntity group : groups) {
assertFalse(group.isDefault());
}
Cluster cluster=m_helper.buildNewCluster(m_clusters,m_serviceFactory,m_componentFactory,m_schFactory,HOSTNAME);
assertEquals(12,m_dao.findAllGroups().size());
AlertDefinitionEntity datanodeProcess=new AlertDefinitionEntity();
datanodeProcess.setClusterId(cluster.getClusterId());
datanodeProcess.setDefinitionName("datanode_process");
datanodeProcess.setServiceName("INVALID");
datanodeProcess.setComponentName("DATANODE");
datanodeProcess.setHash(UUID.randomUUID().toString());
datanodeProcess.setScheduleInterval(60);
datanodeProcess.setScope(Scope.SERVICE);
datanodeProcess.setSource("{\"type\" : \"SCRIPT\"}");
datanodeProcess.setSourceType(SourceType.SCRIPT);
try {
m_definitionDao.create(datanodeProcess);
}
finally {
assertEquals(12,m_dao.findAllGroups().size());
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier targets=new HashSet();
targets.add(target);
AlertGroupEntity group=m_helper.createAlertGroup(m_cluster.getClusterId(),targets);
AlertTargetEntity actual=m_dao.findTargetById(target.getTargetId());
assertNotNull(actual);
assertEquals(target.getTargetName(),actual.getTargetName());
assertEquals(target.getDescription(),actual.getDescription());
assertEquals(target.getNotificationType(),actual.getNotificationType());
assertEquals(target.getProperties(),actual.getProperties());
assertEquals(false,actual.isGlobal());
assertNotNull(actual.getAlertGroups());
Iterator iterator=actual.getAlertGroups().iterator();
AlertGroupEntity actualGroup=iterator.next();
assertEquals(group,actualGroup);
assertEquals(targetCount + 1,m_dao.findAllTargets().size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier definitions=createDefinitions();
AlertGroupEntity group=m_helper.createAlertGroup(m_cluster.getClusterId(),null);
group=m_dao.findGroupById(group.getGroupId());
assertNotNull(group);
for ( AlertDefinitionEntity definition : definitions) {
group.addAlertDefinition(definition);
}
m_dao.merge(group);
group=m_dao.findGroupByName(group.getGroupName());
assertEquals(definitions.size(),group.getAlertDefinitions().size());
for ( AlertDefinitionEntity definition : definitions) {
assertTrue(group.getAlertDefinitions().contains(definition));
}
m_definitionDao.refresh(definitions.get(0));
m_definitionDao.remove(definitions.get(0));
definitions.remove(0);
group=m_dao.findGroupByName(group.getGroupName());
assertEquals(definitions.size(),group.getAlertDefinitions().size());
for ( AlertDefinitionEntity definition : definitions) {
assertTrue(group.getAlertDefinitions().contains(definition));
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=createDefinitions();
AlertGroupEntity group=m_helper.createAlertGroup(m_cluster.getClusterId(),null);
group=m_dao.findGroupById(group.getGroupId());
assertNotNull(group);
AlertDefinitionEntity definition=definitions.get(0);
group.addAlertDefinition(definition);
m_dao.merge(group);
List targets=m_dao.findAllTargets();
AlertTargetEntity target=targets.get(0);
Set setTargets=Collections.singleton(target);
group.setAlertTargets(setTargets);
m_dao.merge(group);
List groups=m_dao.findGroupsByDefinition(definition);
assertEquals(2,groups.size());
group=groups.get(groups.indexOf(group));
assertEquals(1,group.getAlertTargets().size());
assertEquals(target.getTargetId(),group.getAlertTargets().iterator().next().getTargetId());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier targets=new HashSet();
targets.add(target);
AlertGroupEntity group=m_helper.createAlertGroup(m_cluster.getClusterId(),targets);
AlertGroupEntity actual=m_dao.findGroupById(group.getGroupId());
assertNotNull(group);
assertEquals(group.getGroupName(),actual.getGroupName());
assertEquals(group.isDefault(),actual.isDefault());
assertEquals(group.getAlertTargets(),actual.getAlertTargets());
assertEquals(group.getAlertDefinitions(),actual.getAlertDefinitions());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier groups=m_dao.findAllGroups();
assertNotNull(groups);
AlertGroupEntity group=groups.get(3);
AlertGroupEntity actual=m_dao.findGroupByName(group.getClusterId(),group.getGroupName());
assertEquals(group,actual);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier groups=m_dao.findAllGroups();
assertNotNull(groups);
assertEquals(10,groups.size());
}
Class: org.apache.ambari.server.orm.dao.AlertsDAOTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier currentAlerts=m_dao.findAll(request);
assertNotNull(currentAlerts);
assertEquals(1,currentAlerts.size());
hostPredicate=new PredicateBuilder().property(AlertResourceProvider.ALERT_HOST).equals("invalid.apache.org").toPredicate();
request=new AlertCurrentRequest();
request.Predicate=hostPredicate;
currentAlerts=m_dao.findAll(request);
assertNotNull(currentAlerts);
assertEquals(0,currentAlerts.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier currentAlerts=m_dao.findCurrent();
assertNotNull(currentAlerts);
assertEquals(5,currentAlerts.size());
m_dao.removeCurrentByHost("h2");
currentAlerts=m_dao.findCurrent();
assertEquals(5,currentAlerts.size());
m_dao.removeCurrentByHost("h1");
currentAlerts=m_dao.findCurrent();
assertEquals(0,currentAlerts.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier alerts=m_dao.findAll(m_cluster.getClusterId());
assertNotNull(alerts);
assertEquals(50,alerts.size());
}
InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier histories=m_dao.findAll(request);
assertEquals(3,histories.size());
hdfsPredicate=new PredicateBuilder().property(AlertHistoryResourceProvider.ALERT_HISTORY_SERVICE_NAME).equals("HDFS").toPredicate();
yarnPredicate=new PredicateBuilder().property(AlertHistoryResourceProvider.ALERT_HISTORY_SERVICE_NAME).equals("YARN").toPredicate();
clusterAndHdfsPredicate=new PredicateBuilder().property(AlertHistoryResourceProvider.ALERT_HISTORY_CLUSTER_NAME).equals("c1").and().property(AlertHistoryResourceProvider.ALERT_HISTORY_SERVICE_NAME).equals("HDFS").toPredicate();
clusterAndHdfsPredicate=new PredicateBuilder().property(AlertHistoryResourceProvider.ALERT_HISTORY_CLUSTER_NAME).equals("c1").and().property(AlertHistoryResourceProvider.ALERT_HISTORY_SERVICE_NAME).equals("HDFS").toPredicate();
clusterAndHdfsAndCriticalPredicate=new PredicateBuilder().property(AlertHistoryResourceProvider.ALERT_HISTORY_CLUSTER_NAME).equals("c1").and().property(AlertHistoryResourceProvider.ALERT_HISTORY_SERVICE_NAME).equals("HDFS").and().property(AlertHistoryResourceProvider.ALERT_HISTORY_STATE).equals(AlertState.CRITICAL.name()).toPredicate();
hdfsAndCriticalOrWarningPredicate=new PredicateBuilder().begin().property(AlertHistoryResourceProvider.ALERT_HISTORY_SERVICE_NAME).equals("HDFS").and().property(AlertHistoryResourceProvider.ALERT_HISTORY_STATE).equals(AlertState.CRITICAL.name()).end().or().property(AlertHistoryResourceProvider.ALERT_HISTORY_STATE).equals(AlertState.WARNING.name()).toPredicate();
alertNamePredicate=new PredicateBuilder().property(AlertHistoryResourceProvider.ALERT_HISTORY_DEFINITION_NAME).equals("NAMENODE").toPredicate();
request.Predicate=hdfsPredicate;
histories=m_dao.findAll(request);
assertEquals(2,histories.size());
request.Predicate=yarnPredicate;
histories=m_dao.findAll(request);
assertEquals(1,histories.size());
request.Predicate=clusterAndHdfsPredicate;
histories=m_dao.findAll(request);
assertEquals(2,histories.size());
request.Predicate=clusterAndHdfsAndCriticalPredicate;
histories=m_dao.findAll(request);
assertEquals(0,histories.size());
request.Predicate=hdfsAndCriticalOrWarningPredicate;
histories=m_dao.findAll(request);
assertEquals(1,histories.size());
request.Predicate=alertNamePredicate;
histories=m_dao.findAll(request);
assertEquals(1,histories.size());
historyIdPredicate=new PredicateBuilder().property(AlertHistoryResourceProvider.ALERT_HISTORY_ID).equals(histories.get(0).getAlertId()).toPredicate();
request.Predicate=historyIdPredicate;
histories=m_dao.findAll(request);
assertEquals(1,histories.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier currentAlerts=m_dao.findCurrent();
int currentAlertExpectedCount=currentAlerts.size();
assertEquals(5,currentAlertExpectedCount);
AlertCurrentEntity current=currentAlerts.get(0);
AlertHistoryEntity history=current.getAlertHistory();
assertNotNull(history);
currentAlerts=m_dao.findCurrentByService(m_cluster.getClusterId(),history.getServiceName());
assertNotNull(currentAlerts);
assertEquals(currentAlertExpectedCount,currentAlerts.size());
currentAlerts=m_dao.findCurrentByService(m_cluster.getClusterId(),"foo");
assertNotNull(currentAlerts);
assertEquals(0,currentAlerts.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier allStates=new ArrayList();
allStates.add(AlertState.OK);
allStates.add(AlertState.WARNING);
allStates.add(AlertState.CRITICAL);
List history=m_dao.findAll(m_cluster.getClusterId(),allStates);
assertNotNull(history);
assertEquals(50,history.size());
history=m_dao.findAll(m_cluster.getClusterId(),Collections.singletonList(AlertState.OK));
assertNotNull(history);
assertEquals(40,history.size());
history=m_dao.findAll(m_cluster.getClusterId(),Collections.singletonList(AlertState.CRITICAL));
assertNotNull(history);
assertEquals(10,history.size());
history=m_dao.findAll(m_cluster.getClusterId(),Collections.singletonList(AlertState.WARNING));
assertNotNull(history);
assertEquals(0,history.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier currentAlerts=m_dao.findCurrent();
assertNotNull(currentAlerts);
assertEquals(5,currentAlerts.size());
m_dao.removeCurrentByService(m_cluster.getClusterId(),"HDFS");
currentAlerts=m_dao.findCurrent();
assertEquals(5,currentAlerts.size());
m_dao.removeCurrentByService(m_cluster.getClusterId(),"YARN");
currentAlerts=m_dao.findCurrent();
assertEquals(0,currentAlerts.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier history=m_dao.findAll(m_cluster.getClusterId(),calendar.getTime(),null);
assertNotNull(history);
assertEquals(50,history.size());
history=m_dao.findAll(m_cluster.getClusterId(),null,calendar.getTime());
assertNotNull(history);
assertEquals(1,history.size());
calendar.set(2014,Calendar.JANUARY,5);
Date startDate=calendar.getTime();
calendar.set(2014,Calendar.JANUARY,10);
Date endDate=calendar.getTime();
history=m_dao.findAll(m_cluster.getClusterId(),startDate,endDate);
assertNotNull(history);
assertEquals(6,history.size());
calendar.set(2014,Calendar.MARCH,5);
history=m_dao.findAll(m_cluster.getClusterId(),calendar.getTime(),null);
assertNotNull(history);
assertEquals(0,history.size());
history=m_dao.findAll(m_cluster.getClusterId(),endDate,startDate);
assertNotNull(history);
assertEquals(0,history.size());
}
InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier currentAlerts=m_dao.findAll(request);
assertTrue(currentAlerts.size() >= 5);
long lastId=Long.MIN_VALUE;
for ( AlertCurrentEntity alert : currentAlerts) {
assertTrue(lastId < alert.getAlertId());
lastId=alert.getAlertId();
}
sortRequestProperty=new SortRequestProperty(AlertResourceProvider.ALERT_ID,Order.DESC);
request.Sort=new SortRequestImpl(Collections.singletonList(sortRequestProperty));
currentAlerts=m_dao.findAll(request);
assertTrue(currentAlerts.size() >= 5);
lastId=Long.MAX_VALUE;
for ( AlertCurrentEntity alert : currentAlerts) {
assertTrue(lastId > alert.getAlertId());
lastId=alert.getAlertId();
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier sortProperties=new ArrayList();
SortRequest sortRequest=new SortRequestImpl(sortProperties);
AlertHistoryRequest request=new AlertHistoryRequest();
request.Sort=sortRequest;
Predicate clusterPredicate=new PredicateBuilder().property(AlertHistoryResourceProvider.ALERT_HISTORY_CLUSTER_NAME).equals("c1").toPredicate();
request.Predicate=clusterPredicate;
sortProperties.add(new SortRequestProperty(AlertHistoryResourceProvider.ALERT_HISTORY_SERVICE_NAME,Order.ASC));
List histories=m_dao.findAll(request);
assertEquals(3,histories.size());
String lastServiceName=null;
for ( AlertHistoryEntity history : histories) {
if (null == lastServiceName) {
lastServiceName=history.getServiceName();
continue;
}
String currentServiceName=history.getServiceName();
assertTrue(lastServiceName.compareTo(currentServiceName) <= 0);
lastServiceName=currentServiceName;
}
sortProperties.clear();
sortProperties.add(new SortRequestProperty(AlertHistoryResourceProvider.ALERT_HISTORY_SERVICE_NAME,Order.DESC));
histories=m_dao.findAll(request);
assertEquals(3,histories.size());
lastServiceName=null;
for ( AlertHistoryEntity history : histories) {
if (null == lastServiceName) {
lastServiceName=history.getServiceName();
continue;
}
String currentServiceName=history.getServiceName();
assertTrue(lastServiceName.compareTo(currentServiceName) >= 0);
lastServiceName=currentServiceName;
}
}
InternalCallVerifier EqualityVerifier currentAlerts=m_dao.findCurrentByDefinitionId(definition.getDefinitionId());
assertEquals(1,currentAlerts.size());
AlertHistoryEntity history2=new AlertHistoryEntity();
history2.setServiceName(definition.getServiceName());
history2.setClusterId(m_cluster.getClusterId());
history2.setAlertDefinition(definition);
history2.setAlertLabel(definition.getDefinitionName());
history2.setAlertText(definition.getDefinitionName());
history2.setAlertTimestamp(Long.valueOf(1L));
history2.setHostName("h2");
history2.setAlertState(AlertState.OK);
AlertCurrentEntity current2=new AlertCurrentEntity();
current2.setOriginalTimestamp(1L);
current2.setLatestTimestamp(2L);
current2.setAlertHistory(history2);
m_dao.create(current2);
currentAlerts=m_dao.findCurrentByDefinitionId(definition.getDefinitionId());
assertEquals(2,currentAlerts.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier currentAlerts=m_dao.findCurrent();
assertNotNull(currentAlerts);
assertEquals(5,currentAlerts.size());
}
InternalCallVerifier EqualityVerifier histories=m_dao.findAll(request);
assertEquals(3,histories.size());
request.Pagination=new PageRequestImpl(StartingPoint.Beginning,2,0,null,null);
histories=m_dao.findAll(request);
assertEquals(2,histories.size());
request.Pagination=new PageRequestImpl(StartingPoint.Beginning,1,2,null,null);
histories=m_dao.findAll(request);
assertEquals(1,histories.size());
request.Pagination=new PageRequestImpl(StartingPoint.Beginning,1,3,null,null);
histories=m_dao.findAll(request);
assertEquals(0,histories.size());
}
InternalCallVerifier EqualityVerifier currents=m_dao.findCurrentByCluster(m_cluster.getClusterId());
for ( AlertCurrentEntity current : currents) {
current.setMaintenanceState(MaintenanceState.ON);
m_dao.merge(current);
}
summary=m_dao.findCurrentHostCounts(m_cluster.getClusterId());
assertEquals(0,summary.getWarningCount());
assertEquals(0,summary.getCriticalCount());
assertEquals(0,summary.getUnknownCount());
assertEquals(4,summary.getOkCount());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier currentAlerts=m_dao.findAll(request);
assertEquals(1,currentAlerts.size());
hdfsPredicate=new PredicateBuilder().property(AlertResourceProvider.ALERT_SERVICE).equals("HDFS").toPredicate();
yarnPredicate=new PredicateBuilder().property(AlertResourceProvider.ALERT_SERVICE).equals("YARN").toPredicate();
request.Predicate=yarnPredicate;
currentAlerts=m_dao.findAll(request);
assertEquals(5,currentAlerts.size());
request.Predicate=hdfsPredicate;
currentAlerts=m_dao.findAll(request);
assertEquals(0,currentAlerts.size());
}
InternalCallVerifier EqualityVerifier currents=m_dao.findCurrentByCluster(m_cluster.getClusterId());
for ( AlertCurrentEntity current : currents) {
if (current.getMaintenanceState() != MaintenanceState.OFF) {
maintenance++;
continue;
}
switch (current.getAlertHistory().getAlertState()) {
case CRITICAL:
crit++;
break;
case OK:
ok++;
break;
case UNKNOWN:
unk++;
break;
default :
warn++;
break;
}
}
summary=m_dao.findCurrentCounts(m_cluster.getClusterId(),null,null);
assertEquals(ok,summary.getOkCount());
assertEquals(warn,summary.getWarningCount());
assertEquals(crit,summary.getCriticalCount());
assertEquals(unk,summary.getUnknownCount());
assertEquals(maintenance,summary.getMaintenanceCount());
assertEquals(2,summary.getOkCount());
assertEquals(1,summary.getWarningCount());
assertEquals(1,summary.getCriticalCount());
assertEquals(1,summary.getUnknownCount());
assertEquals(0,summary.getMaintenanceCount());
summary=m_dao.findCurrentCounts(m_cluster.getClusterId(),"YARN",null);
assertEquals(2,summary.getOkCount());
assertEquals(1,summary.getWarningCount());
assertEquals(1,summary.getCriticalCount());
assertEquals(1,summary.getUnknownCount());
summary=m_dao.findCurrentCounts(m_cluster.getClusterId(),null,"h1");
assertEquals(2,summary.getOkCount());
assertEquals(1,summary.getWarningCount());
assertEquals(1,summary.getCriticalCount());
assertEquals(1,summary.getUnknownCount());
assertEquals(0,summary.getMaintenanceCount());
summary=m_dao.findCurrentCounts(m_cluster.getClusterId(),"foo",null);
assertEquals(0,summary.getOkCount());
assertEquals(0,summary.getWarningCount());
assertEquals(0,summary.getCriticalCount());
assertEquals(0,summary.getUnknownCount());
assertEquals(0,summary.getMaintenanceCount());
for (AlertCurrentEntity current : currents) {
if (current.getAlertHistory().getAlertState() == AlertState.WARNING) {
current.setMaintenanceState(MaintenanceState.ON);
m_dao.merge(current);
}
}
summary=m_dao.findCurrentCounts(m_cluster.getClusterId(),null,null);
assertEquals(2,summary.getOkCount());
assertEquals(0,summary.getWarningCount());
assertEquals(1,summary.getCriticalCount());
assertEquals(1,summary.getUnknownCount());
assertEquals(1,summary.getMaintenanceCount());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier currentAlerts=m_dao.findCurrent();
assertNotNull(currentAlerts);
assertEquals(5,currentAlerts.size());
AlertCurrentEntity entity=m_dao.findCurrentByHostAndName(m_cluster.getClusterId(),"h1","Alert Definition 1");
assertNotNull(entity);
m_dao.removeCurrentByServiceComponentHost(m_cluster.getClusterId(),entity.getAlertHistory().getServiceName(),entity.getAlertHistory().getComponentName(),entity.getAlertHistory().getHostName());
currentAlerts=m_dao.findCurrent();
assertEquals(4,currentAlerts.size());
}
BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier currents=m_dao.findCurrent();
for ( AlertCurrentEntity current : currents) {
m_dao.remove(current);
}
AlertDefinitionEntity namenode=new AlertDefinitionEntity();
namenode.setDefinitionName("NAMENODE");
namenode.setServiceName("HDFS");
namenode.setComponentName("NAMENODE");
namenode.setClusterId(m_cluster.getClusterId());
namenode.setHash(UUID.randomUUID().toString());
namenode.setScheduleInterval(Integer.valueOf(60));
namenode.setScope(Scope.ANY);
namenode.setSource("{\"type\" : \"SCRIPT\"}");
namenode.setSourceType(SourceType.SCRIPT);
m_definitionDao.create(namenode);
AlertDefinitionEntity datanode=new AlertDefinitionEntity();
datanode.setDefinitionName("DATANODE");
datanode.setServiceName("HDFS");
datanode.setComponentName("DATANODE");
datanode.setClusterId(m_cluster.getClusterId());
datanode.setHash(UUID.randomUUID().toString());
datanode.setScheduleInterval(Integer.valueOf(60));
datanode.setScope(Scope.HOST);
datanode.setSource("{\"type\" : \"SCRIPT\"}");
datanode.setSourceType(SourceType.SCRIPT);
m_definitionDao.create(datanode);
AlertDefinitionEntity aggregate=new AlertDefinitionEntity();
aggregate.setDefinitionName("DATANODE_UP");
aggregate.setServiceName("HDFS");
aggregate.setComponentName(null);
aggregate.setClusterId(m_cluster.getClusterId());
aggregate.setHash(UUID.randomUUID().toString());
aggregate.setScheduleInterval(Integer.valueOf(60));
aggregate.setScope(Scope.SERVICE);
aggregate.setSource("{\"type\" : \"SCRIPT\"}");
aggregate.setSourceType(SourceType.SCRIPT);
m_definitionDao.create(aggregate);
AlertHistoryEntity nnHistory=new AlertHistoryEntity();
nnHistory.setAlertState(AlertState.OK);
nnHistory.setServiceName(namenode.getServiceName());
nnHistory.setComponentName(namenode.getComponentName());
nnHistory.setClusterId(m_cluster.getClusterId());
nnHistory.setAlertDefinition(namenode);
nnHistory.setAlertLabel(namenode.getDefinitionName());
nnHistory.setAlertText(namenode.getDefinitionName());
nnHistory.setAlertTimestamp(calendar.getTimeInMillis());
nnHistory.setHostName(HOSTNAME);
m_dao.create(nnHistory);
AlertCurrentEntity nnCurrent=new AlertCurrentEntity();
nnCurrent.setAlertHistory(nnHistory);
nnCurrent.setLatestText(nnHistory.getAlertText());
nnCurrent.setMaintenanceState(MaintenanceState.OFF);
nnCurrent.setOriginalTimestamp(System.currentTimeMillis());
nnCurrent.setLatestTimestamp(System.currentTimeMillis());
m_dao.create(nnCurrent);
AlertHistoryEntity dnHistory=new AlertHistoryEntity();
dnHistory.setAlertState(AlertState.WARNING);
dnHistory.setServiceName(datanode.getServiceName());
dnHistory.setComponentName(datanode.getComponentName());
dnHistory.setClusterId(m_cluster.getClusterId());
dnHistory.setAlertDefinition(datanode);
dnHistory.setAlertLabel(datanode.getDefinitionName());
dnHistory.setAlertText(datanode.getDefinitionName());
dnHistory.setAlertTimestamp(calendar.getTimeInMillis());
dnHistory.setHostName(HOSTNAME);
m_dao.create(dnHistory);
AlertCurrentEntity dnCurrent=new AlertCurrentEntity();
dnCurrent.setAlertHistory(dnHistory);
dnCurrent.setLatestText(dnHistory.getAlertText());
dnCurrent.setMaintenanceState(MaintenanceState.OFF);
dnCurrent.setOriginalTimestamp(System.currentTimeMillis());
dnCurrent.setLatestTimestamp(System.currentTimeMillis());
m_dao.create(dnCurrent);
AlertHistoryEntity aggregateHistory=new AlertHistoryEntity();
aggregateHistory.setAlertState(AlertState.CRITICAL);
aggregateHistory.setServiceName(aggregate.getServiceName());
aggregateHistory.setComponentName(aggregate.getComponentName());
aggregateHistory.setClusterId(m_cluster.getClusterId());
aggregateHistory.setAlertDefinition(aggregate);
aggregateHistory.setAlertLabel(aggregate.getDefinitionName());
aggregateHistory.setAlertText(aggregate.getDefinitionName());
aggregateHistory.setAlertTimestamp(calendar.getTimeInMillis());
m_dao.create(aggregateHistory);
AlertCurrentEntity aggregateCurrent=new AlertCurrentEntity();
aggregateCurrent.setAlertHistory(aggregateHistory);
aggregateCurrent.setLatestText(aggregateHistory.getAlertText());
aggregateCurrent.setMaintenanceState(MaintenanceState.OFF);
aggregateCurrent.setOriginalTimestamp(System.currentTimeMillis());
aggregateCurrent.setLatestTimestamp(System.currentTimeMillis());
m_dao.create(aggregateCurrent);
currents=m_dao.findCurrent();
assertEquals(3,currents.size());
for ( AlertCurrentEntity current : currents) {
assertEquals(MaintenanceState.OFF,current.getMaintenanceState());
}
Service hdfs=m_clusters.getClusterById(m_cluster.getClusterId()).getService("HDFS");
hdfs.setMaintenanceState(MaintenanceState.ON);
currents=m_dao.findCurrent();
assertEquals(3,currents.size());
for ( AlertCurrentEntity current : currents) {
assertEquals(MaintenanceState.ON,current.getMaintenanceState());
}
hdfs.setMaintenanceState(MaintenanceState.OFF);
currents=m_dao.findCurrent();
assertEquals(3,currents.size());
for ( AlertCurrentEntity current : currents) {
assertEquals(MaintenanceState.OFF,current.getMaintenanceState());
}
Host host=m_clusters.getHost(HOSTNAME);
host.setMaintenanceState(m_cluster.getClusterId(),MaintenanceState.ON);
currents=m_dao.findCurrent();
assertEquals(3,currents.size());
for ( AlertCurrentEntity current : currents) {
if (current.getAlertHistory().getComponentName() != null) {
assertEquals(MaintenanceState.ON,current.getMaintenanceState());
}
else {
assertEquals(MaintenanceState.OFF,current.getMaintenanceState());
}
}
host.setMaintenanceState(m_cluster.getClusterId(),MaintenanceState.OFF);
currents=m_dao.findCurrent();
assertEquals(3,currents.size());
for ( AlertCurrentEntity current : currents) {
assertEquals(MaintenanceState.OFF,current.getMaintenanceState());
}
ServiceComponentHost nnComponent=null;
List schs=m_cluster.getServiceComponentHosts(HOSTNAME);
for ( ServiceComponentHost sch : schs) {
if ("NAMENODE".equals(sch.getServiceComponentName())) {
sch.setMaintenanceState(MaintenanceState.ON);
nnComponent=sch;
}
}
assertNotNull(nnComponent);
currents=m_dao.findCurrent();
assertEquals(3,currents.size());
for ( AlertCurrentEntity current : currents) {
if ("NAMENODE".equals(current.getAlertHistory().getComponentName())) {
assertEquals(MaintenanceState.ON,current.getMaintenanceState());
}
else {
assertEquals(MaintenanceState.OFF,current.getMaintenanceState());
}
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier definitions=m_definitionDao.findAll();
AlertDefinitionEntity definition=definitions.get(0);
AlertHistoryEntity h2CriticalHistory=new AlertHistoryEntity();
h2CriticalHistory.setServiceName(definition.getServiceName());
h2CriticalHistory.setClusterId(m_cluster.getClusterId());
h2CriticalHistory.setAlertDefinition(definition);
h2CriticalHistory.setAlertLabel(definition.getDefinitionName() + " h2");
h2CriticalHistory.setAlertText(definition.getDefinitionName() + " h2");
h2CriticalHistory.setAlertTimestamp(calendar.getTimeInMillis());
h2CriticalHistory.setComponentName(definition.getComponentName());
h2CriticalHistory.setHostName("h2");
h2CriticalHistory.setAlertState(AlertState.CRITICAL);
m_dao.create(h2CriticalHistory);
AlertCurrentEntity h2CriticalCurrent=new AlertCurrentEntity();
h2CriticalCurrent.setAlertHistory(h2CriticalHistory);
h2CriticalCurrent.setLatestTimestamp(new Date().getTime());
h2CriticalCurrent.setOriginalTimestamp(new Date().getTime() - 10800000);
h2CriticalCurrent.setMaintenanceState(MaintenanceState.OFF);
m_dao.create(h2CriticalCurrent);
try {
long clusterId=m_cluster.getClusterId();
AlertSummaryDTO summary=m_dao.findCurrentCounts(clusterId,null,null);
assertEquals(5,summary.getOkCount());
AlertHistoryEntity h1=m_dao.findCurrentByCluster(clusterId).get(2).getAlertHistory();
AlertHistoryEntity h2=m_dao.findCurrentByCluster(clusterId).get(3).getAlertHistory();
AlertHistoryEntity h3=m_dao.findCurrentByCluster(clusterId).get(4).getAlertHistory();
h1.setAlertState(AlertState.WARNING);
m_dao.merge(h1);
h2.setAlertState(AlertState.CRITICAL);
m_dao.merge(h2);
h3.setAlertState(AlertState.UNKNOWN);
m_dao.merge(h3);
Map perHostSummary=m_dao.findCurrentPerHostCounts(clusterId);
AlertSummaryDTO h1summary=m_dao.findCurrentCounts(clusterId,null,"h1");
assertEquals(2,h1summary.getOkCount());
assertEquals(1,h1summary.getWarningCount());
assertEquals(1,h1summary.getCriticalCount());
assertEquals(1,h1summary.getUnknownCount());
assertEquals(0,h1summary.getMaintenanceCount());
AlertSummaryDTO h2summary=m_dao.findCurrentCounts(clusterId,null,"h2");
assertEquals(0,h2summary.getOkCount());
assertEquals(0,h2summary.getWarningCount());
assertEquals(1,h2summary.getCriticalCount());
assertEquals(0,h2summary.getUnknownCount());
assertEquals(0,h2summary.getMaintenanceCount());
AlertSummaryDTO h1PerHostSummary=perHostSummary.get("h1");
assertEquals(h1PerHostSummary.getOkCount(),h1summary.getOkCount());
assertEquals(h1PerHostSummary.getWarningCount(),h1summary.getWarningCount());
assertEquals(h1PerHostSummary.getCriticalCount(),h1summary.getCriticalCount());
assertEquals(h1PerHostSummary.getUnknownCount(),h1summary.getUnknownCount());
assertEquals(h1PerHostSummary.getMaintenanceCount(),h1summary.getMaintenanceCount());
AlertSummaryDTO h2PerHostSummary=perHostSummary.get("h2");
assertEquals(h2PerHostSummary.getOkCount(),h2summary.getOkCount());
assertEquals(h2PerHostSummary.getWarningCount(),h2summary.getWarningCount());
assertEquals(h2PerHostSummary.getCriticalCount(),h2summary.getCriticalCount());
assertEquals(h2PerHostSummary.getUnknownCount(),h2summary.getUnknownCount());
assertEquals(h2PerHostSummary.getMaintenanceCount(),h2summary.getMaintenanceCount());
}
finally {
m_dao.remove(h2CriticalCurrent);
m_dao.remove(h2CriticalHistory);
m_clusters.unmapHostFromCluster("h2",m_cluster.getClusterName());
}
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier currentAlerts=m_dao.findCurrent();
assertNotNull(currentAlerts);
assertEquals(5,currentAlerts.size());
AlertDefinitionEntity definition=currentAlerts.get(0).getAlertHistory().getAlertDefinition();
definition.setEnabled(false);
m_definitionDao.merge(definition);
m_dao.removeCurrentDisabledAlerts();
currentAlerts=m_dao.findCurrent();
assertEquals(4,currentAlerts.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier https:/
* /bugs.eclipse.org/bugs/show_bug.cgi?id=398067 which causes an inner
* entity to be stale.
*/
@Test public void testJPAInnerEntityStaleness(){
List currents=m_dao.findCurrent();
AlertCurrentEntity current=currents.get(0);
AlertHistoryEntity oldHistory=current.getAlertHistory();
AlertHistoryEntity newHistory=new AlertHistoryEntity();
newHistory.setAlertDefinition(oldHistory.getAlertDefinition());
newHistory.setAlertInstance(oldHistory.getAlertInstance());
newHistory.setAlertLabel(oldHistory.getAlertLabel());
if (oldHistory.getAlertState() == AlertState.OK) {
newHistory.setAlertState(AlertState.CRITICAL);
}
else {
newHistory.setAlertState(AlertState.OK);
}
newHistory.setAlertText("New History");
newHistory.setClusterId(oldHistory.getClusterId());
newHistory.setAlertTimestamp(System.currentTimeMillis());
newHistory.setComponentName(oldHistory.getComponentName());
newHistory.setHostName(oldHistory.getHostName());
newHistory.setServiceName(oldHistory.getServiceName());
m_dao.create(newHistory);
assertTrue(newHistory.getAlertId().longValue() != oldHistory.getAlertId().longValue());
current.setAlertHistory(newHistory);
m_dao.merge(current);
AlertCurrentEntity newCurrent=m_dao.findCurrentByHostAndName(newHistory.getClusterId(),newHistory.getHostName(),newHistory.getAlertDefinition().getDefinitionName());
assertEquals(newHistory.getAlertId(),newCurrent.getAlertHistory().getAlertId());
assertEquals(newHistory.getAlertState(),newCurrent.getAlertHistory().getAlertState());
newCurrent=m_dao.findCurrentById(current.getAlertId());
assertEquals(newHistory.getAlertId(),newCurrent.getAlertHistory().getAlertId());
assertEquals(newHistory.getAlertState(),newCurrent.getAlertHistory().getAlertState());
}
TestInitializer InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=m_definitionDao.findAll();
assertNotNull(definitions);
assertEquals(5,definitions.size());
calendar.clear();
calendar.set(2014,Calendar.JANUARY,1);
for ( AlertDefinitionEntity definition : definitions) {
for (int i=0; i < 10; i++) {
AlertHistoryEntity history=new AlertHistoryEntity();
history.setServiceName(definition.getServiceName());
history.setClusterId(m_cluster.getClusterId());
history.setAlertDefinition(definition);
history.setAlertLabel(definition.getDefinitionName() + " " + i);
history.setAlertText(definition.getDefinitionName() + " " + i);
history.setAlertTimestamp(calendar.getTimeInMillis());
history.setComponentName(definition.getComponentName());
history.setHostName("h1");
history.setAlertState(AlertState.OK);
if (i == 0 || i == 5) {
history.setAlertState(AlertState.CRITICAL);
}
calendar.add(Calendar.DATE,1);
m_dao.create(history);
}
}
for ( AlertDefinitionEntity definition : definitions) {
List alerts=m_dao.findAll();
AlertHistoryEntity history=null;
for ( AlertHistoryEntity alert : alerts) {
if (definition.equals(alert.getAlertDefinition())) {
history=alert;
}
}
assertNotNull(history);
AlertCurrentEntity current=new AlertCurrentEntity();
current.setAlertHistory(history);
current.setLatestTimestamp(new Date().getTime());
current.setOriginalTimestamp(new Date().getTime() - 10800000);
current.setMaintenanceState(MaintenanceState.OFF);
m_dao.create(current);
}
}
Class: org.apache.ambari.server.orm.dao.BlueprintDAOTest InternalCallVerifier IdentityVerifier InternalCallVerifier IdentityVerifier EqualityVerifier HybridVerifier query=createStrictMock(TypedQuery.class);
expect(entityManager.createNamedQuery(eq("allBlueprints"),eq(BlueprintEntity.class))).andReturn(query);
expect(query.getResultList()).andReturn(Collections.singletonList(entity));
replay(entityManager,query);
BlueprintDAO dao=new BlueprintDAO();
dao.entityManagerProvider=entityManagerProvider;
List results=dao.findAll();
assertEquals(1,results.size());
assertSame(entity,results.get(0));
verify(entityManagerProvider,entityManager,query);
}
Class: org.apache.ambari.server.orm.dao.ClusterVersionDAOTest InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.dao.ConfigGroupDAOTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier configGroupEntities=configGroupDAO.findAllByTag("HDFS");
Assert.assertNotNull(configGroupEntities);
ConfigGroupEntity configGroupEntity=configGroupEntities.get(0);
Assert.assertNotNull(configGroupEntity);
Assert.assertEquals("c1",configGroupEntity.getClusterEntity().getClusterName());
Assert.assertEquals(Long.valueOf(1),configGroupEntity.getClusterEntity().getClusterId());
Assert.assertEquals("hdfs-1",configGroupEntity.getGroupName());
Assert.assertEquals("HDFS",configGroupEntity.getTag());
Assert.assertEquals("some description",configGroupEntity.getDescription());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier hosts=new ArrayList();
HostEntity hostEntity=new HostEntity();
hostEntity.setHostName("h1");
hostEntity.setOsType("centOS");
hosts.add(hostEntity);
ConfigGroupEntity configGroupEntity=createConfigGroup("c1","hdfs-1","HDFS","some description",hosts,null);
Assert.assertNotNull(hostEntity.getHostId());
Assert.assertNotNull(configGroupEntity);
Assert.assertTrue(configGroupEntity.getConfigGroupHostMappingEntities().size() > 0);
Assert.assertNotNull(configGroupEntity.getConfigGroupHostMappingEntities().iterator().next());
Set hostMappingEntities=configGroupHostMappingDAO.findByHostId(hostEntity.getHostId());
Assert.assertNotNull(hostMappingEntities);
for ( ConfigGroupHostMapping hostMappingEntity : hostMappingEntities) {
Assert.assertEquals(hostEntity.getHostId(),hostMappingEntity.getHostId());
Assert.assertEquals("centOS",hostMappingEntity.getHost().getOsType());
}
}
Class: org.apache.ambari.server.orm.dao.CrudDAOTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier NullVerifier Class: org.apache.ambari.server.orm.dao.GroupDAOTest InternalCallVerifier IdentityVerifier query=createStrictMock(TypedQuery.class);
expect(entityManager.createNamedQuery(eq("groupByName"),eq(GroupEntity.class))).andReturn(query);
expect(query.setParameter("groupname",groupName)).andReturn(query);
expect(query.getSingleResult()).andReturn(entity);
replay(entityManager,query);
final GroupDAO dao=new GroupDAO();
dao.entityManagerProvider=entityManagerProvider;
final GroupEntity result=dao.findGroupByName(groupName);
assertSame(entity,result);
verify(entityManagerProvider,entityManager,query);
}
Class: org.apache.ambari.server.orm.dao.HostConfigMappingDAOTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier target=hostConfigMappingDAO.findByType(1L,hostEntity.getHostId(),"global");
Assert.assertEquals("Expected one result",1,target.size());
for ( HostConfigMapping item : target) Assert.assertEquals("Expected version 'v1'",source.getVersion(),item.getVersion());
}
InternalCallVerifier EqualityVerifier target=hostConfigMappingDAO.findByType(1L,hostEntity.getHostId(),"global");
Assert.assertEquals("Expected one result",1,target.size());
HostConfigMapping toChange=null;
for ( HostConfigMapping item : target) {
Assert.assertEquals("Expected version 'v1'",source.getVersion(),item.getVersion());
Assert.assertEquals("Expected selected flag 1",1,(int)item.getSelected());
toChange=item;
toChange.setSelected(0);
}
hostConfigMappingDAO.merge(toChange);
target=hostConfigMappingDAO.findByType(1L,hostEntity.getHostId(),"global");
Assert.assertEquals("Expected one result",1,target.size());
for ( HostConfigMapping item : target) {
Assert.assertEquals("Expected version 'v1'",source.getVersion(),item.getVersion());
Assert.assertEquals("Expected selected flag 0",0,(int)item.getSelected());
}
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier targets=hostConfigMappingDAO.findSelected(1L,hostEntity.getHostId());
Assert.assertEquals("Expected two entities",2,targets.size());
coreSiteConfigV1.setSelected(0);
hostConfigMappingDAO.merge(coreSiteConfigV1);
createEntity(1L,"h1","core-site","version2");
targets=hostConfigMappingDAO.findSelected(1L,hostEntity.getHostId());
Assert.assertEquals("Expected two entities",2,targets.size());
}
Class: org.apache.ambari.server.orm.dao.HostRoleCommandDAOTest BranchVerifier InternalCallVerifier BooleanVerifier ());
m_requestDAO.create(requestEntity);
AtomicLong stageId=new AtomicLong(1);
HostEntity host=m_hostDAO.findByName("test_host1");
host.setHostRoleCommandEntities(new ArrayList());
long stageIdAutoSkipAll=stageId.getAndIncrement();
createStage(stageIdAutoSkipAll,3,host,requestEntity,HostRoleStatus.PENDING,true,true,true);
List tasks=m_hostRoleCommandDAO.findByRequest(requestId);
for ( HostRoleCommandEntity task : tasks) {
Assert.assertTrue(task.isFailureAutoSkipped());
}
long stageIdSkippableButNoAutoSkip=stageId.getAndIncrement();
createStage(stageIdSkippableButNoAutoSkip,3,host,requestEntity,HostRoleStatus.PENDING,true,false,true);
tasks=m_hostRoleCommandDAO.findByRequest(requestId);
for ( HostRoleCommandEntity task : tasks) {
StageEntity stage=task.getStage();
if (stage.getStageId() == stageIdAutoSkipAll) {
Assert.assertTrue(task.isFailureAutoSkipped());
}
else if (stage.getStageId() == stageIdSkippableButNoAutoSkip) {
Assert.assertFalse(task.isFailureAutoSkipped());
}
}
m_hostRoleCommandDAO.updateAutomaticSkipOnFailure(requestId,false,false);
tasks=m_hostRoleCommandDAO.findByRequest(requestId);
for ( HostRoleCommandEntity task : tasks) {
Assert.assertFalse(task.isFailureAutoSkipped());
}
}
InternalCallVerifier EqualityVerifier ());
m_requestDAO.create(requestEntity);
AtomicLong stageId=new AtomicLong(1);
HostEntity host=m_hostDAO.findByName("test_host1");
host.setHostRoleCommandEntities(new ArrayList());
createStage(stageId.getAndIncrement(),3,host,requestEntity,HostRoleStatus.COMPLETED);
createStage(stageId.getAndIncrement(),2,host,requestEntity,HostRoleStatus.SKIPPED_FAILED);
createStage(stageId.getAndIncrement(),1,host,requestEntity,HostRoleStatus.ABORTED);
List tasks=m_hostRoleCommandDAO.findByStatusBetweenStages(requestId,HostRoleStatus.SKIPPED_FAILED,1,3);
Assert.assertEquals(2,tasks.size());
tasks=m_hostRoleCommandDAO.findByStatusBetweenStages(requestId,HostRoleStatus.SKIPPED_FAILED,1,1);
Assert.assertEquals(0,tasks.size());
}
Class: org.apache.ambari.server.orm.dao.HostVersionDAOTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.dao.KerberosDescriptorDAOTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier capturedArgument=EasyMock.newCapture();
entityManager.persist(capture(capturedArgument));
replay(entityManager);
kerberosDescriptorDAO.create(kerberosDescriptorEntity);
Assert.assertNotNull(capturedArgument);
Assert.assertEquals("The persisted object is not the expected one",kerberosDescriptorEntity,capturedArgument.getValue());
}
Class: org.apache.ambari.server.orm.dao.RepositoryVersionDAOTest UtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier NullVerifier InternalCallVerifier NullVerifier InternalCallVerifier NullVerifier InternalCallVerifier NullVerifier Class: org.apache.ambari.server.orm.dao.RequestDAOTest APIUtilityVerifier InternalCallVerifier EqualityVerifier map=hostRoleCommandDAO.findAggregateCounts(100L);
CalculatedStatus calc2=CalculatedStatus.statusFromStageSummary(map,map.keySet());
Assert.assertEquals(HostRoleStatus.IN_PROGRESS,calc1.getStatus());
Assert.assertEquals(calc1.getStatus(),calc2.getStatus());
Assert.assertEquals(calc1.getPercent(),calc2.getPercent(),0.01d);
Set group=new HashSet();
group.add(2L);
group.add(3L);
group.add(4L);
List stages=stageDAO.findByStageIds(requestEntity.getRequestId(),group);
CalculatedStatus calc3=CalculatedStatus.statusFromStageEntities(stages);
CalculatedStatus calc4=CalculatedStatus.statusFromStageSummary(map,group);
Assert.assertEquals(100d,calc3.getPercent(),0.01d);
Assert.assertEquals(HostRoleStatus.COMPLETED,calc3.getStatus());
Assert.assertEquals(calc3.getPercent(),calc4.getPercent(),0.01d);
Assert.assertEquals(calc3.getStatus(),calc4.getStatus());
}
InternalCallVerifier EqualityVerifier set=Collections.emptySet();
List list=dao.findByPks(set);
Assert.assertEquals(0,list.size());
}
InternalCallVerifier EqualityVerifier list=dao.findAllRequestIds(0,true);
Assert.assertEquals(0,list.size());
}
Class: org.apache.ambari.server.orm.dao.RequestScheduleDAOTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier scheduleEntities=requestScheduleDAO.findByStatus("SCHEDULED");
Assert.assertNotNull(scheduleEntities);
Assert.assertEquals(scheduleEntity,scheduleEntities.get(0));
}
Class: org.apache.ambari.server.orm.dao.ServiceConfigDAOTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier serviceConfigEntities=serviceConfigDAO.getLastServiceConfigs(clusterDAO.findByName("c1").getClusterId());
Assert.assertNotNull(serviceConfigEntities);
Assert.assertEquals(2,serviceConfigEntities.size());
for ( ServiceConfigEntity sce : serviceConfigEntities) {
if ("HDFS".equals(sce.getServiceName())) {
Assert.assertEquals("c1",sce.getClusterEntity().getClusterName());
Assert.assertEquals(Long.valueOf(1),sce.getClusterEntity().getClusterId());
Assert.assertEquals(Long.valueOf(2222L),sce.getCreateTimestamp());
Assert.assertEquals(Long.valueOf(2),sce.getVersion());
Assert.assertTrue(sce.getClusterConfigEntities().isEmpty());
Assert.assertNotNull(sce.getServiceConfigId());
}
if ("YARN".equals(sce.getServiceName())) {
Assert.assertEquals("c1",sce.getClusterEntity().getClusterName());
Assert.assertEquals(Long.valueOf(1),sce.getClusterEntity().getClusterId());
Assert.assertEquals(Long.valueOf(3333L),sce.getCreateTimestamp());
Assert.assertEquals(Long.valueOf(1),sce.getVersion());
Assert.assertTrue(sce.getClusterConfigEntities().isEmpty());
Assert.assertNotNull(sce.getServiceConfigId());
}
Assert.assertEquals("admin",sce.getUser());
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier clusterConfigMappingEntities=clusterDAO.getClusterConfigMappingsByStack(clusterEntity.getClusterId(),HDP_01);
Assert.assertEquals(2,clusterConfigMappingEntities.size());
ClusterConfigMappingEntity e1=clusterConfigMappingEntities.get(0);
String tag1=e1.getTag();
Assert.assertEquals("version1",tag1);
String type1=e1.getType();
Assert.assertEquals("oozie-site",type1);
ClusterConfigMappingEntity e2=clusterConfigMappingEntities.get(1);
String tag2=e2.getTag();
Assert.assertEquals("version2",tag2);
String type2=e2.getType();
Assert.assertEquals("oozie-site",type2);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier clusterConfigMappingEntities=clusterDAO.getClusterConfigMappingsByStack(clusterEntity.getClusterId(),HDP_01);
Collection latestMapingEntities=cluster.getLatestConfigMapping(clusterConfigMappingEntities);
Assert.assertEquals(1,latestMapingEntities.size());
for ( ClusterConfigMappingEntity e : latestMapingEntities) {
Assert.assertEquals("version2",e.getTag());
Assert.assertEquals("oozie-site",e.getType());
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier serviceConfigs=serviceConfigDAO.getAllServiceConfigsForClusterAndStack(clusterId,HDP_01);
Assert.assertEquals(4,serviceConfigs.size());
serviceConfigs=serviceConfigDAO.getAllServiceConfigsForClusterAndStack(clusterId,HDP_02);
Assert.assertEquals(0,serviceConfigs.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier serviceConfigEntities=serviceConfigDAO.getServiceConfigs(clusterDAO.findByName("c1").getClusterId());
Assert.assertNotNull(serviceConfigEntities);
Assert.assertEquals(3,serviceConfigEntities.size());
for ( ServiceConfigEntity sce : serviceConfigEntities) {
if ("HDFS".equals(sce.getServiceName()) && (sce.getVersion() == 1)) {
Assert.assertEquals("c1",sce.getClusterEntity().getClusterName());
Assert.assertEquals(Long.valueOf(1),sce.getClusterEntity().getClusterId());
Assert.assertEquals(Long.valueOf(1111L),sce.getCreateTimestamp());
Assert.assertTrue(sce.getClusterConfigEntities().isEmpty());
Assert.assertNotNull(sce.getServiceConfigId());
}
else if ("HDFS".equals(sce.getServiceName()) && (sce.getVersion() == 2)) {
Assert.assertEquals("c1",sce.getClusterEntity().getClusterName());
Assert.assertEquals(Long.valueOf(1),sce.getClusterEntity().getClusterId());
Assert.assertEquals(Long.valueOf(2222L),sce.getCreateTimestamp());
Assert.assertTrue(sce.getClusterConfigEntities().isEmpty());
Assert.assertNotNull(sce.getServiceConfigId());
}
else if ("YARN".equals(sce.getServiceName())) {
Assert.assertEquals("c1",sce.getClusterEntity().getClusterName());
Assert.assertEquals(Long.valueOf(1),sce.getClusterEntity().getClusterId());
Assert.assertEquals(Long.valueOf(3333L),sce.getCreateTimestamp());
Assert.assertEquals(Long.valueOf(1),sce.getVersion());
Assert.assertTrue(sce.getClusterConfigEntities().isEmpty());
Assert.assertNotNull(sce.getServiceConfigId());
}
else {
Assert.fail();
}
Assert.assertEquals("admin",sce.getUser());
}
}
InternalCallVerifier EqualityVerifier clusterConfigMappingEntities=clusterDAO.getClusterConfigMappingsByStack(clusterEntity.getClusterId(),HDP_01);
Collection latestMapingEntities=cluster.getLatestConfigMapping(clusterConfigMappingEntities);
Assert.assertEquals(1,latestMapingEntities.size());
for ( ClusterConfigMappingEntity e : latestMapingEntities) {
Assert.assertEquals("version2",e.getTag());
Assert.assertEquals("oozie-site",e.getType());
}
}
InternalCallVerifier EqualityVerifier serviceConfigs=serviceConfigDAO.getLatestServiceConfigs(clusterId,HDP_01);
Assert.assertEquals(2,serviceConfigs.size());
serviceConfigs=serviceConfigDAO.getLatestServiceConfigs(clusterId,HDP_02);
Assert.assertEquals(2,serviceConfigs.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier configGroupEntities=configGroupDAO.findAllByTag("OOZIE");
Assert.assertNotNull(configGroupEntities);
ConfigGroupEntity configGroupEntity=configGroupEntities.get(0);
Assert.assertNotNull(configGroupEntity);
Assert.assertEquals("c1",configGroupEntity.getClusterEntity().getClusterName());
Assert.assertEquals(Long.valueOf(1),configGroupEntity.getClusterEntity().getClusterId());
Assert.assertEquals("oozie_server",configGroupEntity.getGroupName());
Assert.assertEquals("OOZIE",configGroupEntity.getTag());
Assert.assertEquals("oozie server",configGroupEntity.getDescription());
List clusterConfigMappingEntities=clusterDAO.getClusterConfigMappingsByStack(clusterEntity.getClusterId(),HDP_01);
Assert.assertEquals(2,clusterConfigMappingEntities.size());
ClusterConfigMappingEntity e1=clusterConfigMappingEntities.get(0);
String tag1=e1.getTag();
Assert.assertEquals("version1",tag1);
String type1=e1.getType();
Assert.assertEquals("oozie-site",type1);
ClusterConfigMappingEntity e2=clusterConfigMappingEntities.get(1);
String tag2=e2.getTag();
Assert.assertEquals("version2",tag2);
String type2=e2.getType();
Assert.assertEquals("oozie-site",type2);
}
Class: org.apache.ambari.server.orm.dao.SettingDAOTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier entities=new HashMap<>();
for (int i=0; i < 3; i++) {
SettingEntity entity=new SettingEntity();
entity.setName("motd" + i);
entity.setContent("test content" + i);
entity.setUpdatedBy("ambari");
entity.setSettingType("ambari-server");
entity.setUpdateTimestamp(System.currentTimeMillis());
entities.put(entity.getName(),entity);
dao.create(entity);
}
retrieveAndValidateSame(entities);
assertEquals(entities.size(),dao.findAll().size());
assertNull(dao.findByName("does-not-exist"));
for ( Map.Entry entry : entities.entrySet()) {
entry.getValue().setContent(Objects.toString(Math.random()));
dao.merge(entry.getValue());
}
retrieveAndValidateSame(entities);
assertEquals(entities.size(),dao.findAll().size());
for ( Map.Entry entry : entities.entrySet()) {
dao.removeByName(entry.getKey());
}
assertEquals(0,dao.findAll().size());
}
Class: org.apache.ambari.server.orm.dao.StageDAOTest InternalCallVerifier EqualityVerifier entities=stageDao.findAll(PropertyHelper.getReadRequest(),predicate);
assertEquals(5,entities.size());
predicate=new PredicateBuilder().property(StageResourceProvider.STAGE_CONTEXT).equals("request context for 3").or().property(StageResourceProvider.STAGE_CONTEXT).equals("request context for 4").toPredicate();
entities=stageDao.findAll(PropertyHelper.getReadRequest(),predicate);
assertEquals(2,entities.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier sortProperties=new ArrayList();
SortRequest sortRequest=new SortRequestImpl(sortProperties);
Predicate predicate=new PredicateBuilder().property(StageResourceProvider.STAGE_CLUSTER_NAME).equals("c1").toPredicate();
sortProperties.add(new SortRequestProperty(StageResourceProvider.STAGE_LOG_INFO,SortRequest.Order.ASC));
Request request=PropertyHelper.getReadRequest(new HashSet(Arrays.asList()),null,null,null,sortRequest);
List entities=stageDao.findAll(request,predicate);
assertEquals(5,entities.size());
String lastInfo=null;
for ( StageEntity entity : entities) {
if (lastInfo == null) {
lastInfo=entity.getLogInfo();
continue;
}
String currentInfo=entity.getLogInfo();
assertTrue(lastInfo.compareTo(currentInfo) <= 0);
lastInfo=currentInfo;
}
sortProperties.clear();
sortProperties.add(new SortRequestProperty(StageResourceProvider.STAGE_LOG_INFO,SortRequest.Order.DESC));
entities=stageDao.findAll(request,predicate);
assertEquals(5,entities.size());
lastInfo=null;
for ( StageEntity entity : entities) {
if (null == lastInfo) {
lastInfo=entity.getLogInfo();
continue;
}
String currentInfo=entity.getLogInfo();
assertTrue(lastInfo.compareTo(currentInfo) >= 0);
lastInfo=currentInfo;
}
}
TestInitializer InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier definitions=stageDao.findAll();
assertNotNull(definitions);
assertEquals(5,definitions.size());
}
Class: org.apache.ambari.server.orm.dao.TopologyLogicalRequestDAOTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier IgnoredMethod HybridVerifier logicalRequestEntities=logicalRequestDAO.findAll();
Assert.assertEquals(1,logicalRequestEntities.size());
TopologyLogicalRequestEntity logicalRequestEntity=logicalRequestEntities.iterator().next();
Assert.assertNotNull(logicalRequestEntity.getTopologyRequestId());
Assert.assertEquals(Long.valueOf(1),logicalRequestEntity.getId());
Assert.assertEquals("description",logicalRequestEntity.getDescription());
Assert.assertNotNull(logicalRequestEntity.getTopologyRequestEntity());
Collection hostRequestEntities=logicalRequestEntity.getTopologyHostRequestEntities();
Assert.assertEquals(1,hostRequestEntities.size());
TopologyHostRequestEntity hostRequestEntity=hostRequestEntities.iterator().next();
Assert.assertNotNull(hostRequestEntity.getTopologyHostGroupEntity());
Assert.assertEquals(hostRequestEntity.getTopologyHostGroupEntity().getId(),hostRequestEntity.getHostGroupId());
Collection taskEntities=hostRequestEntity.getTopologyHostTaskEntities();
Assert.assertEquals(1,taskEntities.size());
TopologyHostTaskEntity taskEntity=taskEntities.iterator().next();
Assert.assertNotNull(taskEntity.getTopologyHostRequestEntity());
Assert.assertNotNull(taskEntity.getTopologyLogicalTaskEntities());
Assert.assertEquals(1,taskEntity.getTopologyLogicalTaskEntities().size());
Assert.assertNotNull(taskEntity.getTopologyLogicalTaskEntities().iterator().next().getTopologyHostTaskEntity());
}
Class: org.apache.ambari.server.orm.dao.TopologyRequestDAOTest InternalCallVerifier EqualityVerifier requestEntities=requestDAO.findByClusterId(clusterId);
Assert.assertEquals("All topology request entities associated with cluster should be removed !",0,requestEntities.size());
}
Class: org.apache.ambari.server.orm.dao.UpgradeDAOTest InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier items=dao.findUpgrades(clusterId.longValue());
assertTrue(items.size() > 0);
UpgradeEntity entity=dao.findUpgrade(items.get(0).getId().longValue());
assertNotNull(entity);
assertEquals(1,entity.getUpgradeGroups().size());
UpgradeGroupEntity group=dao.findUpgradeGroup(entity.getUpgradeGroups().get(0).getId().longValue());
assertNotNull(group);
Assert.assertNotSame(entity.getUpgradeGroups().get(0),group);
assertEquals("group_name",group.getName());
assertEquals("group title",group.getTitle());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier items=dao.findUpgrades(clusterId.longValue());
assertEquals(1,items.size());
}
Class: org.apache.ambari.server.orm.dao.WidgetDAOTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.dao.WidgetLayoutDAOTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier widgetLayoutEntityList1=widgetLayoutDAO.findBySectionName("section0");
List widgetLayoutEntityList2=widgetLayoutDAO.findBySectionName("section1");
Assert.assertEquals(1,widgetLayoutEntityList1.size());
Assert.assertEquals(1,widgetLayoutEntityList2.size());
Assert.assertEquals(3,widgetLayoutEntityList1.get(0).getListWidgetLayoutUserWidgetEntity().size());
}
Class: org.apache.ambari.server.orm.entities.BlueprintConfigEntityPKTest InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.BlueprintConfigEntityTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier IdentityVerifier Class: org.apache.ambari.server.orm.entities.BlueprintEntityTest InternalCallVerifier IdentityVerifier hostGroups=Collections.emptyList();
entity.setHostGroups(hostGroups);
assertSame(hostGroups,entity.getHostGroups());
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier IdentityVerifier configurations=Collections.emptyList();
entity.setConfigurations(configurations);
assertSame(configurations,entity.getConfigurations());
}
Class: org.apache.ambari.server.orm.entities.HostEntityTest InternalCallVerifier BooleanVerifier ());
Collection stateEntities=hostEntity.getHostComponentStateEntities();
assertTrue(stateEntities.isEmpty());
hostEntity.addHostComponentStateEntity(stateEntity);
stateEntities=hostEntity.getHostComponentStateEntities();
assertTrue(stateEntities.contains(stateEntity));
hostEntity.removeHostComponentStateEntity(stateEntity);
stateEntities=hostEntity.getHostComponentStateEntities();
assertFalse(stateEntities.contains(stateEntity));
}
InternalCallVerifier BooleanVerifier ());
Collection stateEntities=hostEntity.getHostComponentDesiredStateEntities();
assertTrue(stateEntities.isEmpty());
hostEntity.addHostComponentDesiredStateEntity(stateEntity);
stateEntities=hostEntity.getHostComponentDesiredStateEntities();
assertTrue(stateEntities.contains(stateEntity));
hostEntity.removeHostComponentDesiredStateEntity(stateEntity);
stateEntities=hostEntity.getHostComponentDesiredStateEntities();
assertFalse(stateEntities.contains(stateEntity));
}
InternalCallVerifier BooleanVerifier ());
Collection stateEntities=hostEntity.getHostComponentStateEntities();
assertTrue(stateEntities.isEmpty());
hostEntity.addHostComponentStateEntity(stateEntity);
stateEntities=hostEntity.getHostComponentStateEntities();
assertTrue(stateEntities.contains(stateEntity));
}
UtilityVerifier InternalCallVerifier BooleanVerifier HybridVerifier ());
Collection stateEntities=hostEntity.getHostComponentStateEntities();
assertTrue(stateEntities.isEmpty());
try {
stateEntities.add(stateEntity);
fail("Expected UnsupportedOperationException");
}
catch ( UnsupportedOperationException e) {
}
}
UtilityVerifier InternalCallVerifier BooleanVerifier HybridVerifier ());
Collection stateEntities=hostEntity.getHostComponentDesiredStateEntities();
assertTrue(stateEntities.isEmpty());
try {
stateEntities.add(stateEntity);
fail("Expected UnsupportedOperationException");
}
catch ( UnsupportedOperationException e) {
}
}
InternalCallVerifier BooleanVerifier ());
Collection stateEntities=hostEntity.getHostComponentDesiredStateEntities();
assertTrue(stateEntities.isEmpty());
hostEntity.addHostComponentDesiredStateEntity(stateEntity);
stateEntities=hostEntity.getHostComponentDesiredStateEntities();
assertTrue(stateEntities.contains(stateEntity));
}
Class: org.apache.ambari.server.orm.entities.HostGroupComponentEntityTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier IdentityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.HostGroupConfigEntityPKTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.HostGroupConfigEntityTest InternalCallVerifier EqualityVerifier InternalCallVerifier IdentityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.HostGroupEntityTest InternalCallVerifier EqualityVerifier InternalCallVerifier IdentityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier IdentityVerifier components=Collections.emptyList();
entity.setComponents(components);
assertSame(components,entity.getComponents());
}
InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.LdapSyncEventEntityTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier emptyList());
event.setSpecs(Collections.singletonList(spec));
List specs=event.getSpecs();
Assert.assertEquals(1,specs.size());
Assert.assertEquals(spec,specs.get(0));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.PrincipalEntityTest InternalCallVerifier EqualityVerifier privileges=new HashSet();
PrivilegeEntity privilegeEntity1=new PrivilegeEntity();
privilegeEntity1.setId(1);
privileges.add(privilegeEntity1);
PrivilegeEntity privilegeEntity2=new PrivilegeEntity();
privilegeEntity2.setId(2);
privileges.add(privilegeEntity2);
PrincipalEntity entity=new PrincipalEntity();
entity.setPrivileges(privileges);
entity.removePrivilege(privilegeEntity2);
privileges=entity.getPrivileges();
Assert.assertEquals(1,privileges.size());
privileges.contains(privilegeEntity1);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier privileges=new HashSet();
PrivilegeEntity privilegeEntity=new PrivilegeEntity();
privilegeEntity.setId(1);
privileges.add(privilegeEntity);
privilegeEntity=new PrivilegeEntity();
privilegeEntity.setId(2);
privileges.add(privilegeEntity);
PrincipalEntity entity=new PrincipalEntity();
entity.setPrivileges(privileges);
Assert.assertEquals(privileges,entity.getPrivileges());
}
Class: org.apache.ambari.server.orm.entities.PrincipalTypeEntityTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.ResourceEntityTest InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier privileges=Collections.singleton(privilegeEntity);
Assert.assertNull(entity.getResourceType());
entity.setPrivileges(privileges);
Assert.assertEquals(privileges,entity.getPrivileges());
}
InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.ResourceTypeEntityTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.ServiceConfigEntityTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.SettingEntityTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.StageEntityTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.ViewEntityEntityTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.ViewEntityTest InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier definitions=viewDefinition.getInstances();
Assert.assertEquals(1,definitions.size());
Assert.assertTrue(definitions.contains(definition));
verify(definition);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier types=viewDefinition.getViewResourceTypes();
Assert.assertEquals(2,types.size());
Assert.assertTrue(types.contains(type1));
Assert.assertTrue(types.contains(type2));
}
InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.orm.entities.ViewInstanceEntityTest APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier dataMap=viewInstanceDefinition.getInstanceDataMap();
Assert.assertEquals(5,dataMap.size());
Assert.assertEquals("foo",dataMap.get("key1"));
Assert.assertEquals("bar",dataMap.get("key2"));
Assert.assertEquals("baz",dataMap.get("key3"));
Assert.assertEquals("monkey",dataMap.get("key4"));
Assert.assertEquals("runner",dataMap.get("key5"));
viewInstanceDefinition.removeInstanceData("key3");
dataMap=viewInstanceDefinition.getInstanceDataMap();
Assert.assertEquals(4,dataMap.size());
Assert.assertFalse(dataMap.containsKey("key3"));
securityHelper.setUser("user2");
dataMap=viewInstanceDefinition.getInstanceDataMap();
Assert.assertTrue(dataMap.isEmpty());
viewInstanceDefinition.putInstanceData("key1","aaa");
viewInstanceDefinition.putInstanceData("key2","bbb");
viewInstanceDefinition.putInstanceData("key3","ccc");
dataMap=viewInstanceDefinition.getInstanceDataMap();
Assert.assertEquals(3,dataMap.size());
Assert.assertEquals("aaa",dataMap.get("key1"));
Assert.assertEquals("bbb",dataMap.get("key2"));
Assert.assertEquals("ccc",dataMap.get("key3"));
securityHelper.setUser("user1");
dataMap=viewInstanceDefinition.getInstanceDataMap();
Assert.assertEquals(4,dataMap.size());
Assert.assertEquals("foo",dataMap.get("key1"));
Assert.assertEquals("bar",dataMap.get("key2"));
Assert.assertNull(dataMap.get("key3"));
Assert.assertEquals("monkey",dataMap.get("key4"));
Assert.assertEquals("runner",dataMap.get("key5"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyResults=result.getPropertyResults();
junit.framework.Assert.assertEquals(2,propertyResults.size());
junit.framework.Assert.assertTrue(propertyResults.containsKey("p1"));
junit.framework.Assert.assertTrue(propertyResults.containsKey("p2"));
junit.framework.Assert.assertTrue(propertyResults.get("p1").isValid());
junit.framework.Assert.assertTrue(propertyResults.get("p2").isValid());
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier properties=viewInstanceDefinition.getPropertyMap();
Assert.assertEquals(3,properties.size());
Assert.assertEquals("v1",properties.get("p1"));
Assert.assertEquals("v2",properties.get("p2"));
Assert.assertEquals("v3",properties.get("p3"));
}
Class: org.apache.ambari.server.proxy.ProxyServiceTest InternalCallVerifier IdentityVerifier queryParams=new MultivaluedMapImpl();
MultivaluedMap headerParams=new MultivaluedMapImpl();
Map> headerParamsToForward=new HashMap>();
Response.ResponseBuilder responseBuilderMock=PowerMock.createMock(ResponseBuilderImpl.class);
Response responseMock=createMock(ResponseImpl.class);
headerParams.add("AmbariProxy-User-Remote","testuser");
headerParams.add("Content-Type","testtype");
List userRemoteParams=new LinkedList();
userRemoteParams.add("testuser");
headerParamsToForward.put("User-Remote",userRemoteParams);
InputStream is=new ByteArrayInputStream("test".getBytes());
PowerMock.mockStatic(Response.class);
expect(getHttpHeaders().getRequestHeaders()).andReturn(headerParams);
expect(getHttpHeaders().getRequestHeader("AmbariProxy-User-Remote")).andReturn(userRemoteParams);
expect(getUriInfo().getRequestUri()).andReturn(uriMock);
expect(getUriInfo().getQueryParameters()).andReturn(queryParams);
expect(uriMock.getQuery()).andReturn("url=testurl");
expect(streamProviderMock.processURL("testurl","GET",(InputStream)null,headerParamsToForward)).andReturn(urlConnectionMock);
expect(urlConnectionMock.getResponseCode()).andReturn(200);
expect(urlConnectionMock.getContentType()).andReturn("text/plain");
expect(urlConnectionMock.getInputStream()).andReturn(is);
PowerMock.expectNew(URLStreamProvider.class,20000,15000,null,null,null).andReturn(streamProviderMock);
expect(Response.status(200)).andReturn(responseBuilderMock);
expect(responseBuilderMock.entity(is)).andReturn(responseBuilderMock);
expect(responseBuilderMock.type("text/plain")).andReturn(responseBuilderMock);
expect(responseBuilderMock.build()).andReturn(responseMock);
PowerMock.replay(streamProviderMock,URLStreamProvider.class,Response.class,responseBuilderMock,uriMock,URI.class);
replay(getUriInfo(),urlConnectionMock,getHttpHeaders());
Response resultForGetRequest=ps.processGetRequestForwarding(getHttpHeaders(),getUriInfo());
assertSame(resultForGetRequest,responseMock);
}
InternalCallVerifier IdentityVerifier queryParams=new MultivaluedMapImpl();
MultivaluedMap headerParams=new MultivaluedMapImpl();
Map> headerParamsToForward=new HashMap>();
Response.ResponseBuilder responseBuilderMock=PowerMock.createMock(ResponseBuilderImpl.class);
Response responseMock=createMock(ResponseImpl.class);
headerParams.add("AmbariProxy-User-Remote","testuser");
headerParams.add("Content-Type","testtype");
List userRemoteParams=new LinkedList();
userRemoteParams.add("testuser");
headerParamsToForward.put("User-Remote",userRemoteParams);
InputStream is=new ByteArrayInputStream("test".getBytes());
PowerMock.mockStatic(Response.class);
expect(getHttpHeaders().getRequestHeaders()).andReturn(headerParams);
expect(getHttpHeaders().getRequestHeader("AmbariProxy-User-Remote")).andReturn(userRemoteParams);
expect(getUriInfo().getRequestUri()).andReturn(uriMock);
expect(getUriInfo().getQueryParameters()).andReturn(queryParams);
expect(uriMock.getQuery()).andReturn("url=testurl");
expect(getHttpHeaders().getMediaType()).andReturn(APPLICATION_FORM_URLENCODED_TYPE);
expect(streamProviderMock.processURL("testurl","PUT",is,headerParamsToForward)).andReturn(urlConnectionMock);
expect(urlConnectionMock.getResponseCode()).andReturn(200);
expect(urlConnectionMock.getContentType()).andReturn("text/plain");
expect(urlConnectionMock.getInputStream()).andReturn(is);
PowerMock.expectNew(URLStreamProvider.class,20000,15000,null,null,null).andReturn(streamProviderMock);
expect(Response.status(200)).andReturn(responseBuilderMock);
expect(responseBuilderMock.entity(is)).andReturn(responseBuilderMock);
expect(responseBuilderMock.type("text/plain")).andReturn(responseBuilderMock);
expect(responseBuilderMock.build()).andReturn(responseMock);
PowerMock.replay(streamProviderMock,URLStreamProvider.class,Response.class,responseBuilderMock,uriMock,URI.class);
replay(getUriInfo(),urlConnectionMock,getHttpHeaders());
Response resultForPutRequest=ps.processPutRequestForwarding(is,getHttpHeaders(),getUriInfo());
assertSame(resultForPutRequest,responseMock);
}
InternalCallVerifier IdentityVerifier queryParams=new MultivaluedMapImpl();
MultivaluedMap headerParams=new MultivaluedMapImpl();
Map> headerParamsToForward=new HashMap>();
headerParams.add("AmbariProxy-User-Remote","testuser");
headerParams.add("Content-Type","testtype");
List userRemoteParams=new LinkedList();
userRemoteParams.add("testuser");
headerParamsToForward.put("User-Remote",userRemoteParams);
PowerMock.mockStatic(Response.class);
expect(getHttpHeaders().getRequestHeaders()).andReturn(headerParams);
expect(getHttpHeaders().getRequestHeader("AmbariProxy-User-Remote")).andReturn(userRemoteParams);
expect(getUriInfo().getRequestUri()).andReturn(uriMock);
expect(getUriInfo().getQueryParameters()).andReturn(queryParams);
expect(uriMock.getQuery()).andReturn("url=testurl");
expect(streamProviderMock.processURL("testurl","GET",(InputStream)null,headerParamsToForward)).andReturn(urlConnectionMock);
expect(urlConnectionMock.getResponseCode()).andReturn(400).times(2);
expect(urlConnectionMock.getContentType()).andReturn("text/plain");
expect(urlConnectionMock.getErrorStream()).andReturn(es);
expect(Response.status(400)).andReturn(responseBuilderMock);
expect(responseBuilderMock.entity(es)).andReturn(responseBuilderMock);
expect(responseBuilderMock.type("text/plain")).andReturn(responseBuilderMock);
expect(responseBuilderMock.build()).andReturn(responseMock);
PowerMock.expectNew(URLStreamProvider.class,20000,15000,null,null,null).andReturn(streamProviderMock);
PowerMock.replay(streamProviderMock,URLStreamProvider.class,uriMock,URI.class,Response.class,responseBuilderMock);
replay(getUriInfo(),urlConnectionMock,getHttpHeaders());
Response resultForErrorRequest=ps.processGetRequestForwarding(getHttpHeaders(),getUriInfo());
assertSame(resultForErrorRequest,responseMock);
}
InternalCallVerifier IdentityVerifier queryParams=new MultivaluedMapImpl();
MultivaluedMap headerParams=new MultivaluedMapImpl();
Map> headerParamsToForward=new HashMap>();
Response.ResponseBuilder responseBuilderMock=PowerMock.createMock(ResponseBuilderImpl.class);
Response responseMock=createMock(ResponseImpl.class);
headerParams.add("AmbariProxy-User-Remote","testuser");
headerParams.add("Content-Type","testtype");
List userRemoteParams=new LinkedList();
userRemoteParams.add("testuser");
headerParamsToForward.put("User-Remote",userRemoteParams);
InputStream is=new ByteArrayInputStream("test".getBytes());
PowerMock.mockStatic(Response.class);
expect(getHttpHeaders().getRequestHeaders()).andReturn(headerParams);
expect(getHttpHeaders().getRequestHeader("AmbariProxy-User-Remote")).andReturn(userRemoteParams);
expect(getUriInfo().getRequestUri()).andReturn(uriMock);
expect(getUriInfo().getQueryParameters()).andReturn(queryParams);
expect(uriMock.getQuery()).andReturn("url=testurl");
expect(streamProviderMock.processURL("testurl","DELETE",(InputStream)null,headerParamsToForward)).andReturn(urlConnectionMock);
expect(urlConnectionMock.getResponseCode()).andReturn(200);
expect(urlConnectionMock.getContentType()).andReturn("text/plain");
expect(urlConnectionMock.getInputStream()).andReturn(is);
PowerMock.expectNew(URLStreamProvider.class,20000,15000,null,null,null).andReturn(streamProviderMock);
expect(Response.status(200)).andReturn(responseBuilderMock);
expect(responseBuilderMock.entity(is)).andReturn(responseBuilderMock);
expect(responseBuilderMock.type("text/plain")).andReturn(responseBuilderMock);
expect(responseBuilderMock.build()).andReturn(responseMock);
PowerMock.replay(streamProviderMock,URLStreamProvider.class,Response.class,responseBuilderMock,uriMock,URI.class);
replay(getUriInfo(),urlConnectionMock,getHttpHeaders());
Response resultForDeleteRequest=ps.processDeleteRequestForwarding(getHttpHeaders(),getUriInfo());
assertSame(resultForDeleteRequest,responseMock);
}
InternalCallVerifier IdentityVerifier queryParams=new MultivaluedMapImpl();
MultivaluedMap headerParams=new MultivaluedMapImpl();
Map> headerParamsToForward=new HashMap>();
Response.ResponseBuilder responseBuilderMock=PowerMock.createMock(ResponseBuilderImpl.class);
Response responseMock=createMock(ResponseImpl.class);
headerParams.add("AmbariProxy-User-Remote","testuser");
headerParams.add("Content-Type","testtype");
List userRemoteParams=new LinkedList();
userRemoteParams.add("testuser");
headerParamsToForward.put("User-Remote",userRemoteParams);
Map map=new Gson().fromJson(new InputStreamReader(new ByteArrayInputStream("{ \"test\":\"test\" }".getBytes())),Map.class);
PowerMock.mockStatic(Response.class);
expect(getHttpHeaders().getRequestHeaders()).andReturn(headerParams);
expect(getHttpHeaders().getRequestHeader("AmbariProxy-User-Remote")).andReturn(userRemoteParams);
expect(getUriInfo().getRequestUri()).andReturn(uriMock);
expect(getUriInfo().getQueryParameters()).andReturn(queryParams);
expect(uriMock.getQuery()).andReturn("url=testurl");
expect(streamProviderMock.processURL("testurl","GET",(InputStream)null,headerParamsToForward)).andReturn(urlConnectionMock);
expect(urlConnectionMock.getResponseCode()).andReturn(200);
expect(urlConnectionMock.getContentType()).andReturn("application/json");
expect(urlConnectionMock.getInputStream()).andReturn(new ByteArrayInputStream("{ \"test\":\"test\" }".getBytes()));
PowerMock.expectNew(URLStreamProvider.class,20000,15000,null,null,null).andReturn(streamProviderMock);
expect(Response.status(200)).andReturn(responseBuilderMock);
expect(responseBuilderMock.entity(map)).andReturn(responseBuilderMock);
expect(responseBuilderMock.type("application/json")).andReturn(responseBuilderMock);
expect(responseBuilderMock.build()).andReturn(responseMock);
PowerMock.replay(streamProviderMock,URLStreamProvider.class,Response.class,responseBuilderMock,uriMock,URI.class);
replay(getUriInfo(),urlConnectionMock,getHttpHeaders());
Response resultForGetRequest=ps.processGetRequestForwarding(getHttpHeaders(),getUriInfo());
assertSame(resultForGetRequest,responseMock);
}
InternalCallVerifier IdentityVerifier queryParams=new MultivaluedMapImpl();
MultivaluedMap headerParams=new MultivaluedMapImpl();
Map> headerParamsToForward=new HashMap>();
Response.ResponseBuilder responseBuilderMock=PowerMock.createMock(ResponseBuilderImpl.class);
Response responseMock=createMock(ResponseImpl.class);
headerParams.add("AmbariProxy-User-Remote","testuser");
headerParams.add("Content-Type","testtype");
List userRemoteParams=new LinkedList();
userRemoteParams.add("testuser");
headerParamsToForward.put("User-Remote",userRemoteParams);
InputStream is=new ByteArrayInputStream("test".getBytes());
PowerMock.mockStatic(Response.class);
expect(getHttpHeaders().getRequestHeaders()).andReturn(headerParams);
expect(getHttpHeaders().getRequestHeader("AmbariProxy-User-Remote")).andReturn(userRemoteParams);
expect(getUriInfo().getRequestUri()).andReturn(uriMock);
expect(getUriInfo().getQueryParameters()).andReturn(queryParams);
expect(uriMock.getQuery()).andReturn("url=testurl");
expect(getHttpHeaders().getMediaType()).andReturn(APPLICATION_FORM_URLENCODED_TYPE);
expect(streamProviderMock.processURL("testurl","POST",is,headerParamsToForward)).andReturn(urlConnectionMock);
expect(urlConnectionMock.getResponseCode()).andReturn(200);
expect(urlConnectionMock.getContentType()).andReturn("text/plain");
expect(urlConnectionMock.getInputStream()).andReturn(is);
PowerMock.expectNew(URLStreamProvider.class,20000,15000,null,null,null).andReturn(streamProviderMock);
expect(Response.status(200)).andReturn(responseBuilderMock);
expect(responseBuilderMock.entity(is)).andReturn(responseBuilderMock);
expect(responseBuilderMock.type("text/plain")).andReturn(responseBuilderMock);
expect(responseBuilderMock.build()).andReturn(responseMock);
PowerMock.replay(streamProviderMock,URLStreamProvider.class,Response.class,responseBuilderMock,uriMock,URI.class);
replay(getUriInfo(),urlConnectionMock,getHttpHeaders());
Response resultForPostRequest=ps.processPostRequestForwarding(is,getHttpHeaders(),getUriInfo());
assertSame(resultForPostRequest,responseMock);
}
Class: org.apache.ambari.server.resources.TestResources APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.scheduler.ExecutionScheduleManagerTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier triggers=(List)scheduler.getTriggersOfJob(jobKey);
Trigger trigger=triggers != null && !triggers.isEmpty() ? triggers.get(0) : null;
Date nextFireTime=trigger != null ? trigger.getNextFireTime() : null;
LOG.info("[jobName] : " + jobName + " [groupName] : "+ jobGroup+ " - "+ nextFireTime);
if (jobName.equals(jobName1)) {
jobDetail1=scheduler.getJobDetail(jobKey);
trigger1=trigger;
}
else if (jobName.equals(jobName2)) {
jobDetail2=scheduler.getJobDetail(jobKey);
trigger2=trigger;
}
}
}
Assert.assertNotNull(jobDetail1);
Assert.assertNotNull(trigger1);
Assert.assertNotNull(jobDetail2);
Assert.assertNull(trigger2);
CronTrigger cronTrigger=(CronTrigger)trigger1;
Schedule schedule=new Schedule();
schedule.setMinutes("10");
schedule.setHours("2");
schedule.setMonth("*");
schedule.setDaysOfMonth("*");
schedule.setDayOfWeek("?");
Assert.assertEquals(schedule.getScheduleExpression(),cronTrigger.getCronExpression());
Assert.assertEquals(jobName1,jobDetail1.getKey().getName());
Assert.assertEquals(jobName2,jobDetail2.getKey().getName());
}
APIUtilityVerifier TestInitializer InternalCallVerifier NullVerifier ConditionMatcher HybridVerifier InternalCallVerifier BooleanVerifier executionMap=new HashMap();
executionMap.put(executionId,requestExecutionMock);
expect(clustersMock.getCluster(clusterName)).andReturn(clusterMock).anyTimes();
expect(clusterMock.getAllRequestExecutions()).andReturn(executionMap).anyTimes();
expect(requestExecutionMock.getBatch()).andReturn(batchMock).anyTimes();
expect(batchMock.getBatchSettings()).andReturn(batchSettings).anyTimes();
replay(clustersMock,clusterMock,configurationMock,requestExecutionMock,executionSchedulerMock,batchMock);
ExecutionScheduleManager scheduleManager=new ExecutionScheduleManager(configurationMock,executionSchedulerMock,tokenStorageMock,clustersMock,actionDBAccessorMock,gson);
HashMap taskCounts=new HashMap(){
{
put(BatchRequestJob.BATCH_REQUEST_FAILED_TASKS_KEY,2);
put(BatchRequestJob.BATCH_REQUEST_TOTAL_TASKS_KEY,10);
}
}
;
boolean exceeded=scheduleManager.hasToleranceThresholdExceeded(executionId,clusterName,taskCounts);
Assert.assertTrue(exceeded);
verify(clustersMock,clusterMock,configurationMock,requestExecutionMock,executionSchedulerMock,batchMock);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier ConditionMatcher HybridVerifier Class: org.apache.ambari.server.scheduler.ExecutionSchedulerTest InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.security.AbstractSecurityHeaderFilterTest APIUtilityVerifier InternalCallVerifier NullVerifier APIUtilityVerifier InternalCallVerifier NullVerifier APIUtilityVerifier InternalCallVerifier NullVerifier APIUtilityVerifier InternalCallVerifier NullVerifier APIUtilityVerifier InternalCallVerifier NullVerifier APIUtilityVerifier InternalCallVerifier NullVerifier Class: org.apache.ambari.server.security.CertGenerationTest InternalCallVerifier BooleanVerifier IgnoredMethod HybridVerifier InternalCallVerifier BooleanVerifier IgnoredMethod HybridVerifier config=certMan.configs.getConfigsMap();
config.put(Configuration.PASSPHRASE_KEY,"passphrase");
String agentHostname="agent_hostname";
SignCertResponse scr=certMan.signAgentCrt(agentHostname,"incorrect_agentCrtReqContent","passphrase");
Assert.assertFalse(scr.getMessage().contains("-revoke"));
File fakeAgentCertFile=new File(temp.getRoot().getAbsoluteFile() + File.separator + agentHostname+ ".crt");
Assert.assertTrue(fakeAgentCertFile.exists());
scr=certMan.signAgentCrt(agentHostname,"incorrect_agentCrtReqContent","passphrase");
Assert.assertTrue(scr.getMessage().contains("-revoke"));
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier IgnoredMethod HybridVerifier Class: org.apache.ambari.server.security.SecurePasswordHelperTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.security.SecurityFilterTest InternalCallVerifier EqualityVerifier InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.security.SslExecutionTest InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.security.authorization.AmbariAuthorizationProviderDisableUserTest UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.security.authorization.AmbariLdapAuthenticationProviderForDNWithSpaceTest InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.security.authorization.AmbariLdapAuthenticationProviderTest InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.security.authorization.AmbariLocalUserDetailsServiceTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.security.authorization.AuthorizationHelperTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier privilegeEntities=new ArrayList();
ResourceTypeEntity resourceTypeEntity=new ResourceTypeEntity();
resourceTypeEntity.setId(1);
resourceTypeEntity.setName("CLUSTER");
ResourceEntity resourceEntity=new ResourceEntity();
resourceEntity.setId(1L);
resourceEntity.setResourceType(resourceTypeEntity);
PrincipalTypeEntity principalTypeEntity=new PrincipalTypeEntity();
principalTypeEntity.setId(1);
principalTypeEntity.setName("USER");
PrincipalEntity principalEntity=new PrincipalEntity();
principalEntity.setPrincipalType(principalTypeEntity);
principalEntity.setId(1L);
PermissionEntity permissionEntity1=new PermissionEntity();
permissionEntity1.setPermissionName("Permission1");
permissionEntity1.setResourceType(resourceTypeEntity);
permissionEntity1.setId(2);
permissionEntity1.setPermissionName("CLUSTER.USER");
PermissionEntity permissionEntity2=new PermissionEntity();
permissionEntity2.setPermissionName("Permission1");
permissionEntity2.setResourceType(resourceTypeEntity);
permissionEntity2.setId(3);
permissionEntity2.setPermissionName("CLUSTER.ADMINISTRATOR");
PrivilegeEntity privilegeEntity1=new PrivilegeEntity();
privilegeEntity1.setId(1);
privilegeEntity1.setPermission(permissionEntity1);
privilegeEntity1.setPrincipal(principalEntity);
privilegeEntity1.setResource(resourceEntity);
PrivilegeEntity privilegeEntity2=new PrivilegeEntity();
privilegeEntity2.setId(1);
privilegeEntity2.setPermission(permissionEntity2);
privilegeEntity2.setPrincipal(principalEntity);
privilegeEntity2.setResource(resourceEntity);
privilegeEntities.add(privilegeEntity1);
privilegeEntities.add(privilegeEntity2);
Collection authorities=new AuthorizationHelper().convertPrivilegesToAuthorities(privilegeEntities);
assertEquals("Wrong number of authorities",2,authorities.size());
Set authorityNames=new HashSet();
for ( GrantedAuthority authority : authorities) {
authorityNames.add(authority.getAuthority());
}
Assert.assertTrue(authorityNames.contains("CLUSTER.USER@1"));
Assert.assertTrue(authorityNames.contains("CLUSTER.ADMINISTRATOR@1"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier emptyList());
Authentication readOnlyUser=new TestAuthentication(Collections.singleton(readOnlyAuthority));
Authentication privilegedUser=new TestAuthentication(Arrays.asList(readOnlyAuthority,privilegedAuthority));
Authentication privileged2User=new TestAuthentication(Arrays.asList(readOnly2Authority,privileged2Authority));
Authentication administratorUser=new TestAuthentication(Collections.singleton(administratorAuthority));
SecurityContext context=SecurityContextHolder.getContext();
assertFalse(AuthorizationHelper.isAuthorized(null,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertFalse(AuthorizationHelper.isAuthorized(noAccessUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertFalse(AuthorizationHelper.isAuthorized(noAccessUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertFalse(AuthorizationHelper.isAuthorized(noAccessUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.AMBARI_MANAGE_USERS)));
assertTrue(AuthorizationHelper.isAuthorized(readOnlyUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertFalse(AuthorizationHelper.isAuthorized(readOnlyUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertFalse(AuthorizationHelper.isAuthorized(readOnlyUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.AMBARI_MANAGE_USERS)));
assertTrue(AuthorizationHelper.isAuthorized(privilegedUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertTrue(AuthorizationHelper.isAuthorized(privilegedUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertFalse(AuthorizationHelper.isAuthorized(privilegedUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.AMBARI_MANAGE_USERS)));
assertFalse(AuthorizationHelper.isAuthorized(privileged2User,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertFalse(AuthorizationHelper.isAuthorized(privileged2User,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertFalse(AuthorizationHelper.isAuthorized(privileged2User,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.AMBARI_MANAGE_USERS)));
assertTrue(AuthorizationHelper.isAuthorized(administratorUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertTrue(AuthorizationHelper.isAuthorized(administratorUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertTrue(AuthorizationHelper.isAuthorized(administratorUser,ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.AMBARI_MANAGE_USERS)));
context.setAuthentication(noAccessUser);
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
context.setAuthentication(readOnlyUser);
assertTrue(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.AMBARI_MANAGE_USERS)));
context.setAuthentication(privilegedUser);
assertTrue(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertTrue(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.AMBARI_MANAGE_USERS)));
context.setAuthentication(privileged2User);
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertFalse(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.AMBARI_MANAGE_USERS)));
context.setAuthentication(administratorUser);
assertTrue(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_VIEW_METRICS)));
assertTrue(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.CLUSTER_TOGGLE_KERBEROS)));
assertTrue(AuthorizationHelper.isAuthorized(ResourceType.CLUSTER,1L,EnumSet.of(RoleAuthorization.AMBARI_MANAGE_USERS)));
}
Class: org.apache.ambari.server.security.authorization.LdapServerPropertiesTest InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier urls=ldapServerProperties.getLdapUrls();
assertEquals(INCORRECT_URL_LIST,1,urls.size());
assertEquals(INCORRECT_URL_LIST,"ldap://1.2.3.4:389",urls.get(0));
ldapServerProperties.setSecondaryUrl("4.3.2.1:1234");
urls=ldapServerProperties.getLdapUrls();
assertEquals(INCORRECT_URL_LIST,2,urls.size());
assertEquals(INCORRECT_URL_LIST,"ldap://4.3.2.1:1234",urls.get(1));
ldapServerProperties.setUseSsl(true);
urls=ldapServerProperties.getLdapUrls();
assertEquals(INCORRECT_URL_LIST,"ldaps://1.2.3.4:389",urls.get(0));
assertEquals(INCORRECT_URL_LIST,"ldaps://4.3.2.1:1234",urls.get(1));
}
InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.security.authorization.TestUsers InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier UtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier IdentityVerifier HybridVerifier InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier userList=users.getAllUsers();
assertEquals(2,userList.size());
for ( User user : userList) {
assertEquals(false,user.isLdapUser());
}
assertEquals(2,userDAO.findAll().size());
UserEntity userEntity=userDAO.findUserByName("user");
assertNotNull("user",userEntity.getUserPassword());
users.modifyPassword("user","user","resu");
assertNotSame(userEntity.getUserPassword(),userDAO.findUserByName("user").getUserPassword());
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier UtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier groupList=users.getAllGroups();
assertEquals(2,groupList.size());
assertEquals(2,groupDAO.findAll().size());
}
UtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier HybridVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier IdentityVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.security.authorization.jwt.JwtAuthenticationFilterTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.security.encryption.AESEncryptorTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier InternalCallVerifier EqualityVerifier PublicFieldVerifier Class: org.apache.ambari.server.security.encryption.CredentialProviderTest UtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.security.encryption.CredentialStoreServiceImplTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier credentials=credentialStoreService.listCredentials(CLUSTER_NAME);
Assert.assertNotNull(credentials);
Assert.assertEquals(4,credentials.size());
Assert.assertEquals(CredentialStoreType.PERSISTED,credentials.get("test1"));
Assert.assertEquals(CredentialStoreType.PERSISTED,credentials.get("test2"));
Assert.assertEquals(CredentialStoreType.TEMPORARY,credentials.get("test3"));
Assert.assertEquals(CredentialStoreType.TEMPORARY,credentials.get("test4"));
}
UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier TestInitializer InternalCallVerifier BooleanVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.security.encryption.MasterKeyServiceTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier permissions=Files.getPosixFilePermissions(Paths.get(masterKeyFile.getAbsolutePath()));
Assert.assertNotNull(permissions);
Assert.assertEquals(2,permissions.size());
Assert.assertTrue(permissions.contains(PosixFilePermission.OWNER_READ));
Assert.assertTrue(permissions.contains(PosixFilePermission.OWNER_WRITE));
Assert.assertFalse(permissions.contains(PosixFilePermission.OWNER_EXECUTE));
Assert.assertFalse(permissions.contains(PosixFilePermission.GROUP_READ));
Assert.assertFalse(permissions.contains(PosixFilePermission.GROUP_WRITE));
Assert.assertFalse(permissions.contains(PosixFilePermission.GROUP_EXECUTE));
Assert.assertFalse(permissions.contains(PosixFilePermission.OTHERS_READ));
Assert.assertFalse(permissions.contains(PosixFilePermission.OTHERS_WRITE));
Assert.assertFalse(permissions.contains(PosixFilePermission.OTHERS_EXECUTE));
MasterKeyService ms1=new MasterKeyServiceImpl(masterKeyFile);
Assert.assertTrue(ms1.isMasterKeyInitialized());
Assert.assertEquals("ThisisSomePassPhrase",new String(ms1.getMasterSecret()));
Assert.assertEquals(new String(ms.getMasterSecret()),new String(ms1.getMasterSecret()));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier mapRet=new HashMap();
mapRet.put(Configuration.MASTER_KEY_ENV_PROP,"ThisisSomePassPhrase");
mockStatic(System.class);
expect(System.getenv()).andReturn(mapRet);
replayAll();
MasterKeyService ms=new MasterKeyServiceImpl();
verifyAll();
Assert.assertTrue(ms.isMasterKeyInitialized());
Assert.assertNotNull(ms.getMasterSecret());
Assert.assertEquals("ThisisSomePassPhrase",new String(ms.getMasterSecret()));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier mapRet=new HashMap();
mapRet.put(Configuration.MASTER_KEY_LOCATION,masterKeyFile.getAbsolutePath());
mockStatic(System.class);
expect(System.getenv()).andReturn(mapRet);
replayAll();
ms=new MasterKeyServiceImpl();
verifyAll();
Assert.assertTrue(ms.isMasterKeyInitialized());
Assert.assertNotNull(ms.getMasterSecret());
Assert.assertEquals("ThisisSomePassPhrase",new String(ms.getMasterSecret()));
Assert.assertFalse(masterKeyFile.exists());
}
Class: org.apache.ambari.server.security.ldap.AmbariLdapDataPopulatorTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier groupList=Arrays.asList(group1,group2,group3,group4);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllGroups()).andReturn(groupList);
expect(users.getAllUsers()).andReturn(Collections.EMPTY_LIST);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(group1,group2,group3,group4);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("refreshGroupMembers").addMockedMethod("getExternalLdapGroupInfo").withConstructor(configuration,users).createNiceMock();
LdapGroupDto externalGroup1=createNiceMock(LdapGroupDto.class);
expect(externalGroup1.getGroupName()).andReturn("group3").anyTimes();
LdapBatchDto batchInfo=new LdapBatchDto();
Set externalGroups=createSet(externalGroup1);
for ( LdapGroupDto externalGroup : externalGroups) {
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
}
expect(populator.getExternalLdapGroupInfo()).andReturn(externalGroups);
replay(populator);
replay(externalGroup1);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeAllLdapGroups(batchInfo);
assertEquals(2,result.getGroupsToBeRemoved().size());
assertTrue(result.getGroupsToBeRemoved().contains("group2"));
assertTrue(result.getGroupsToBeRemoved().contains("group4"));
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier internalMembers=new HashMap();
internalMembers.put("user1",user1);
internalMembers.put("user3",user3);
internalMembers.put("user4",user4);
LdapBatchDto batchInfo=new LdapBatchDto();
LdapUserDto externalUser1=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser2=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser3=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser4=createNiceMock(LdapUserDto.class);
expect(externalUser1.getUserName()).andReturn("user1").anyTimes();
expect(externalUser2.getUserName()).andReturn("user2").anyTimes();
expect(externalUser3.getUserName()).andReturn("user4").anyTimes();
expect(externalUser4.getUserName()).andReturn("user6").anyTimes();
replay(externalUser1,externalUser2,externalUser3,externalUser4);
expect(populator.getLdapUserByMemberAttr("user1")).andReturn(externalUser1).anyTimes();
expect(populator.getLdapUserByMemberAttr("user2")).andReturn(externalUser2).anyTimes();
expect(populator.getLdapUserByMemberAttr("user4")).andReturn(null).anyTimes();
expect(populator.getLdapGroupByMemberAttr("user4")).andReturn(externalGroup).anyTimes();
expect(populator.getLdapUserByMemberAttr("user6")).andReturn(externalUser4).anyTimes();
expect(populator.getInternalMembers("group1")).andReturn(internalMembers).anyTimes();
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
Map internalUsers=new HashMap();
internalUsers.putAll(internalMembers);
internalUsers.put("user2",user2);
Map internalGroups=new HashMap();
internalGroups.put("group2",group2);
populator.refreshGroupMembers(batchInfo,externalGroup,internalUsers,internalGroups,null);
Set groupMembersToAdd=new HashSet();
for ( LdapUserGroupMemberDto ldapUserGroupMemberDto : batchInfo.getMembershipToAdd()) {
groupMembersToAdd.add(ldapUserGroupMemberDto.getUserName());
}
assertEquals(3,groupMembersToAdd.size());
assertTrue(groupMembersToAdd.contains("user2"));
assertTrue(groupMembersToAdd.contains("user6"));
Set groupMembersToRemove=new HashSet();
for ( LdapUserGroupMemberDto ldapUserGroupMemberDto : batchInfo.getMembershipToRemove()) {
groupMembersToRemove.add(ldapUserGroupMemberDto.getUserName());
}
assertEquals(2,groupMembersToRemove.size());
assertTrue(groupMembersToRemove.contains("user3"));
assertEquals(1,batchInfo.getUsersToBeCreated().size());
assertTrue(batchInfo.getUsersToBeCreated().contains("user6"));
assertEquals(1,batchInfo.getUsersToBecomeLdap().size());
assertTrue(batchInfo.getUsersToBecomeLdap().contains("user1"));
assertTrue(!batchInfo.getUsersToBecomeLdap().contains("user4"));
assertTrue(batchInfo.getGroupsToBecomeLdap().isEmpty());
assertEquals(1,batchInfo.getGroupsToBeCreated().size());
assertTrue(batchInfo.getGroupsToBeRemoved().isEmpty());
assertTrue(batchInfo.getUsersToBeRemoved().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
InternalCallVerifier NullVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier groupList=Arrays.asList(group1,group2,group3,group4);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllGroups()).andReturn(groupList);
expect(users.getAllUsers()).andReturn(Collections.EMPTY_LIST);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(group1,group2,group3,group4);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getLdapGroups").addMockedMethod("refreshGroupMembers").withConstructor(configuration,users).createNiceMock();
LdapGroupDto externalGroup1=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup2=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup3=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup4=createNiceMock(LdapGroupDto.class);
expect(externalGroup1.getGroupName()).andReturn("group1").anyTimes();
expect(externalGroup2.getGroupName()).andReturn("group2").anyTimes();
expect(externalGroup3.getGroupName()).andReturn("group3").anyTimes();
expect(externalGroup4.getGroupName()).andReturn("group4").anyTimes();
replay(externalGroup1,externalGroup2,externalGroup3,externalGroup4);
LdapBatchDto batchInfo=new LdapBatchDto();
Set externalGroups=createSet(externalGroup1,externalGroup2,externalGroup3,externalGroup4);
for ( LdapGroupDto externalGroup : externalGroups) {
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
}
expect(populator.getLdapGroups("group*")).andReturn(externalGroups);
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeLdapGroups(createSet("group*"),batchInfo);
assertEquals(2,result.getGroupsToBecomeLdap().size());
assertTrue(result.getGroupsToBecomeLdap().contains("group1"));
assertTrue(result.getGroupsToBecomeLdap().contains("group4"));
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier userList=Arrays.asList(user1,user2,user3);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllUsers()).andReturn(userList);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(user1,user2,user3);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getExternalLdapUserInfo").withConstructor(configuration,users).createNiceMock();
expect(populator.getExternalLdapUserInfo()).andReturn(Collections.EMPTY_SET);
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeAllLdapUsers(new LdapBatchDto());
assertEquals(2,result.getUsersToBeRemoved().size());
assertTrue(result.getUsersToBeRemoved().contains("user3"));
assertTrue(result.getUsersToBeRemoved().contains("user1"));
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier userList=Arrays.asList(user1,user2);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllUsers()).andReturn(userList);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(user1,user2);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getExternalLdapUserInfo").withConstructor(configuration,users).createNiceMock();
LdapUserDto externalUser1=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser2=createNiceMock(LdapUserDto.class);
expect(externalUser1.getUserName()).andReturn("user3").anyTimes();
expect(externalUser2.getUserName()).andReturn("user4").anyTimes();
replay(externalUser1,externalUser2);
expect(populator.getExternalLdapUserInfo()).andReturn(createSet(externalUser1,externalUser2));
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeAllLdapUsers(new LdapBatchDto());
assertEquals(2,result.getUsersToBeCreated().size());
assertTrue(result.getUsersToBeCreated().contains("user3"));
assertTrue(result.getUsersToBeCreated().contains("user4"));
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier ());
final User ldapUserWithoutGroup=createLdapUserWithoutGroup();
final User ldapUserWithGroup=createLdapUserWithGroup(ldapGroup);
final User localUserWithoutGroup=createLocalUserWithoutGroup();
final User localUserWithGroup=createLocalUserWithGroup(ldapGroup);
final List allUsers=new ArrayList(){
{
add(ldapUserWithoutGroup);
add(ldapUserWithGroup);
add(localUserWithoutGroup);
add(localUserWithGroup);
}
}
;
expect(users.getAllUsers()).andReturn(new ArrayList(allUsers));
final List removedUsers=new ArrayList();
final Capture userCapture=new Capture();
users.removeUser(capture(userCapture));
expectLastCall().andAnswer(new IAnswer(){
@Override public Void answer() throws Throwable {
removedUsers.add(userCapture.getValue());
allUsers.remove(userCapture.getValue());
return null;
}
}
);
replay(users);
final AmbariLdapDataPopulatorTestInstance populator=new AmbariLdapDataPopulatorTestInstance(configuration,users);
populator.setLdapTemplate(createNiceMock(LdapTemplate.class));
populator.setLdapServerProperties(createNiceMock(LdapServerProperties.class));
populator.cleanUpLdapUsersWithoutGroup();
assertEquals(removedUsers.size(),1);
assertEquals(allUsers.size(),3);
assertTrue(allUsers.contains(ldapUserWithGroup));
assertTrue(allUsers.contains(localUserWithoutGroup));
assertTrue(allUsers.contains(localUserWithGroup));
assertEquals(removedUsers.get(0),ldapUserWithoutGroup);
verify(users);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier externalGroups=createSet(externalGroup1,externalGroup2);
for ( LdapGroupDto externalGroup : externalGroups) {
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
}
expect(populator.getExternalLdapGroupInfo()).andReturn(externalGroups);
replay(externalGroup1,externalGroup2);
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeAllLdapGroups(batchInfo);
assertEquals(2,result.getGroupsToBeCreated().size());
assertTrue(result.getGroupsToBeCreated().contains("group3"));
assertTrue(result.getGroupsToBeCreated().contains("group4"));
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier userList=Arrays.asList(user1,user2,user3,user4);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllUsers()).andReturn(userList);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(user1,user2,user3,user4);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getLdapUsers").withConstructor(configuration,users).createNiceMock();
LdapUserDto externalUser2=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser3=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser4=createNiceMock(LdapUserDto.class);
expect(externalUser2.getUserName()).andReturn("user2").anyTimes();
expect(externalUser3.getUserName()).andReturn("xuser3").anyTimes();
expect(externalUser4.getUserName()).andReturn("xuser4").anyTimes();
replay(externalUser2,externalUser3,externalUser4);
expect(populator.getLdapUsers("xuser*")).andReturn(createSet(externalUser3,externalUser4));
expect(populator.getLdapUsers("user2")).andReturn(Collections.singleton(externalUser2));
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeLdapUsers(createSet("user2","xuser*"),new LdapBatchDto());
assertEquals(2,result.getUsersToBeCreated().size());
assertTrue(result.getUsersToBeCreated().contains("xuser3"));
assertTrue(result.getUsersToBeCreated().contains("xuser4"));
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier userList=Arrays.asList(user1,user2,user3,user4);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllUsers()).andReturn(userList);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(user1,user3,user2,user4);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getExternalLdapUserInfo").withConstructor(configuration,users).createNiceMock();
LdapUserDto externalUser1=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser2=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser3=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser4=createNiceMock(LdapUserDto.class);
expect(externalUser1.getUserName()).andReturn("synced_user2").anyTimes();
expect(externalUser2.getUserName()).andReturn("unsynced_user2").anyTimes();
expect(externalUser3.getUserName()).andReturn("external_user1").anyTimes();
expect(externalUser4.getUserName()).andReturn("external_user2").anyTimes();
replay(externalUser1,externalUser2,externalUser3,externalUser4);
expect(populator.getExternalLdapUserInfo()).andReturn(createSet(externalUser1,externalUser2,externalUser3,externalUser4));
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeAllLdapUsers(new LdapBatchDto());
assertEquals(1,result.getUsersToBeRemoved().size());
assertTrue(result.getUsersToBeRemoved().contains("synced_user1"));
assertEquals(2,result.getUsersToBeCreated().size());
assertTrue(result.getUsersToBeCreated().contains("external_user1"));
assertTrue(result.getUsersToBeCreated().contains("external_user2"));
assertEquals(1,result.getUsersToBecomeLdap().size());
assertTrue(result.getUsersToBecomeLdap().contains("unsynced_user2"));
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier groupList=Arrays.asList(group1,group2,group3,group4);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllGroups()).andReturn(groupList);
expect(users.getAllUsers()).andReturn(Collections.EMPTY_LIST);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(group1,group2,group3,group4);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getLdapGroups").addMockedMethod("refreshGroupMembers").withConstructor(configuration,users).createNiceMock();
LdapGroupDto externalGroup1=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup2=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup3=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup4=createNiceMock(LdapGroupDto.class);
expect(externalGroup1.getGroupName()).andReturn("group1").anyTimes();
expect(externalGroup2.getGroupName()).andReturn("group2").anyTimes();
expect(externalGroup3.getGroupName()).andReturn("xgroup1").anyTimes();
expect(externalGroup4.getGroupName()).andReturn("xgroup2").anyTimes();
replay(externalGroup1,externalGroup2,externalGroup3,externalGroup4);
LdapBatchDto batchInfo=new LdapBatchDto();
Set externalGroups=createSet(externalGroup3,externalGroup4);
for ( LdapGroupDto externalGroup : externalGroups) {
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
}
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup2),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
expect(populator.getLdapGroups("x*")).andReturn(externalGroups);
expect(populator.getLdapGroups("group2")).andReturn(Collections.singleton(externalGroup2));
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeLdapGroups(createSet("x*","group2"),batchInfo);
assertEquals(2,result.getGroupsToBeCreated().size());
assertTrue(result.getGroupsToBeCreated().contains("xgroup1"));
assertTrue(result.getGroupsToBeCreated().contains("xgroup2"));
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
InternalCallVerifier BooleanVerifier anyObject(),EasyMock.anyObject(),EasyMock.anyObject())).andReturn(Collections.emptyList()).once();
replay(ldapTemplate,configuration);
final AmbariLdapDataPopulatorTestInstance populator=new AmbariLdapDataPopulatorTestInstance(configuration,users);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
assertTrue(populator.isLdapEnabled());
verify(populator.loadLdapTemplate(),configuration);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier userList=Arrays.asList(user1,user2,user3,user4);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllUsers()).andReturn(userList);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(user1,user2,user3,user4);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getLdapUsers").withConstructor(configuration,users).createNiceMock();
expect(populator.getLdapUsers("synced_user1")).andReturn(Collections.EMPTY_SET);
expect(populator.getLdapUsers("synced_user2")).andReturn(Collections.singleton(createNiceMock(LdapUserDto.class)));
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeExistingLdapUsers(new LdapBatchDto());
assertEquals(1,result.getUsersToBeRemoved().size());
assertTrue(result.getUsersToBeRemoved().contains("synced_user1"));
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier userList=Arrays.asList(user1,user2,user3);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllUsers()).andReturn(userList);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(user1,user2,user3);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getExternalLdapUserInfo").withConstructor(configuration,users).createNiceMock();
LdapUserDto externalUser1=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser2=createNiceMock(LdapUserDto.class);
expect(externalUser1.getUserName()).andReturn("user1").anyTimes();
expect(externalUser2.getUserName()).andReturn("user3").anyTimes();
replay(externalUser1,externalUser2);
expect(populator.getExternalLdapUserInfo()).andReturn(createSet(externalUser1,externalUser2));
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeAllLdapUsers(new LdapBatchDto());
assertEquals(1,result.getUsersToBecomeLdap().size());
assertTrue(result.getUsersToBecomeLdap().contains("user3"));
assertTrue(result.getUsersToBeRemoved().isEmpty());
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier userList=Arrays.asList(user1,user2,user3,user4);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllUsers()).andReturn(userList);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(user1,user2,user3,user4);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getLdapUsers").withConstructor(configuration,users).createNiceMock();
LdapUserDto externalUser1=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser2=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser3=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser4=createNiceMock(LdapUserDto.class);
expect(externalUser1.getUserName()).andReturn("user1").anyTimes();
expect(externalUser2.getUserName()).andReturn("user2").anyTimes();
expect(externalUser3.getUserName()).andReturn("xuser3").anyTimes();
expect(externalUser4.getUserName()).andReturn("xuser4").anyTimes();
replay(externalUser1,externalUser2,externalUser3,externalUser4);
expect(populator.getLdapUsers("xuser*")).andReturn(createSet(externalUser3,externalUser4));
expect(populator.getLdapUsers("user1")).andReturn(Collections.singleton(externalUser1));
expect(populator.getLdapUsers("user2")).andReturn(Collections.singleton(externalUser2));
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeLdapUsers(createSet("user1","user2","xuser*"),new LdapBatchDto());
assertEquals(2,result.getUsersToBeCreated().size());
assertTrue(result.getUsersToBeCreated().contains("xuser3"));
assertTrue(result.getUsersToBeCreated().contains("xuser4"));
assertEquals(1,result.getUsersToBecomeLdap().size());
assertTrue(result.getUsersToBecomeLdap().contains("user1"));
assertTrue(result.getUsersToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier groupList=Arrays.asList(group1,group2,group3,group4,group5);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllGroups()).andReturn(groupList);
expect(users.getAllUsers()).andReturn(Collections.EMPTY_LIST);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(group1,group2,group3,group4,group5);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getExternalLdapGroupInfo").addMockedMethod("refreshGroupMembers").withConstructor(configuration,users).createNiceMock();
LdapGroupDto externalGroup1=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup2=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup3=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup4=createNiceMock(LdapGroupDto.class);
expect(externalGroup1.getGroupName()).andReturn("group4").anyTimes();
expect(externalGroup2.getGroupName()).andReturn("group3").anyTimes();
expect(externalGroup3.getGroupName()).andReturn("group6").anyTimes();
expect(externalGroup4.getGroupName()).andReturn("group7").anyTimes();
LdapBatchDto batchInfo=new LdapBatchDto();
Set externalGroups=createSet(externalGroup1,externalGroup2,externalGroup3,externalGroup4);
for ( LdapGroupDto externalGroup : externalGroups) {
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
}
expect(populator.getExternalLdapGroupInfo()).andReturn(externalGroups);
replay(externalGroup1,externalGroup2,externalGroup3,externalGroup4);
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeAllLdapGroups(batchInfo);
assertEquals(1,result.getGroupsToBeRemoved().size());
assertTrue(result.getGroupsToBeRemoved().contains("group2"));
assertEquals(1,result.getGroupsToBecomeLdap().size());
assertTrue(result.getGroupsToBecomeLdap().contains("group3"));
assertEquals(2,result.getGroupsToBeCreated().size());
assertTrue(result.getGroupsToBeCreated().contains("group6"));
assertTrue(result.getGroupsToBeCreated().contains("group7"));
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier groupList=Arrays.asList(group1,group2,group3);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllGroups()).andReturn(groupList);
expect(users.getAllUsers()).andReturn(Collections.EMPTY_LIST);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(group1,group2,group3);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("refreshGroupMembers").addMockedMethod("getExternalLdapGroupInfo").withConstructor(configuration,users).createNiceMock();
LdapGroupDto externalGroup1=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup2=createNiceMock(LdapGroupDto.class);
expect(externalGroup1.getGroupName()).andReturn("group2").anyTimes();
expect(externalGroup2.getGroupName()).andReturn("group3").anyTimes();
LdapBatchDto batchInfo=new LdapBatchDto();
Set externalGroups=createSet(externalGroup1,externalGroup2);
for ( LdapGroupDto externalGroup : externalGroups) {
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
}
expect(populator.getExternalLdapGroupInfo()).andReturn(externalGroups);
replay(populator);
replay(externalGroup1,externalGroup2);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeAllLdapGroups(batchInfo);
assertEquals(2,result.getGroupsToBecomeLdap().size());
assertTrue(result.getGroupsToBecomeLdap().contains("group2"));
assertTrue(result.getGroupsToBecomeLdap().contains("group3"));
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier groupList=Arrays.asList(group1,group2,group3,group4,group5);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllGroups()).andReturn(groupList);
expect(users.getAllUsers()).andReturn(Collections.EMPTY_LIST);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(group1,group2,group3,group4,group5);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getLdapGroups").addMockedMethod("refreshGroupMembers").withConstructor(configuration,users).createNiceMock();
expect(populator.getLdapGroups("group2")).andReturn(Collections.EMPTY_SET);
LdapGroupDto externalGroup1=createNiceMock(LdapGroupDto.class);
LdapBatchDto batchInfo=new LdapBatchDto();
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup1),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
expect(populator.getLdapGroups("group4")).andReturn(Collections.singleton(externalGroup1));
expect(populator.getLdapGroups("group5")).andReturn(Collections.EMPTY_SET);
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeExistingLdapGroups(batchInfo);
assertEquals(2,result.getGroupsToBeRemoved().size());
assertTrue(result.getGroupsToBeRemoved().contains("group2"));
assertTrue(result.getGroupsToBeRemoved().contains("group5"));
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier groupList=Arrays.asList(group1,group2,group3,group4);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllGroups()).andReturn(groupList);
expect(users.getAllUsers()).andReturn(Collections.EMPTY_LIST);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(group1,group2,group3,group4);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getLdapGroups").addMockedMethod("refreshGroupMembers").withConstructor(configuration,users).createNiceMock();
LdapGroupDto externalGroup1=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup2=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup3=createNiceMock(LdapGroupDto.class);
LdapGroupDto externalGroup4=createNiceMock(LdapGroupDto.class);
expect(externalGroup1.getGroupName()).andReturn("group1").anyTimes();
expect(externalGroup2.getGroupName()).andReturn("group2").anyTimes();
expect(externalGroup3.getGroupName()).andReturn("xgroup1").anyTimes();
expect(externalGroup4.getGroupName()).andReturn("xgroup2").anyTimes();
replay(externalGroup1,externalGroup2,externalGroup3,externalGroup4);
LdapBatchDto batchInfo=new LdapBatchDto();
Set externalGroups=createSet(externalGroup3,externalGroup4);
for ( LdapGroupDto externalGroup : externalGroups) {
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
}
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup1),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
populator.refreshGroupMembers(eq(batchInfo),eq(externalGroup2),anyObject(Map.class),anyObject(Map.class),anyObject(Set.class));
expectLastCall();
expect(populator.getLdapGroups("x*")).andReturn(externalGroups);
expect(populator.getLdapGroups("group1")).andReturn(Collections.singleton(externalGroup1));
expect(populator.getLdapGroups("group2")).andReturn(Collections.singleton(externalGroup2));
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeLdapGroups(createSet("x*","group1","group2"),batchInfo);
assertEquals(1,result.getGroupsToBecomeLdap().size());
assertTrue(result.getGroupsToBecomeLdap().contains("group1"));
assertEquals(2,result.getGroupsToBeCreated().size());
assertTrue(result.getGroupsToBeCreated().contains("xgroup1"));
assertTrue(result.getGroupsToBeCreated().contains("xgroup2"));
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
assertTrue(result.getUsersToBecomeLdap().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier userList=Arrays.asList(user1,user2,user3,user4);
Configuration configuration=createNiceMock(Configuration.class);
Users users=createNiceMock(Users.class);
LdapTemplate ldapTemplate=createNiceMock(LdapTemplate.class);
LdapServerProperties ldapServerProperties=createNiceMock(LdapServerProperties.class);
expect(users.getAllUsers()).andReturn(userList);
replay(ldapTemplate,ldapServerProperties,users,configuration);
replay(user1,user2,user3,user4);
AmbariLdapDataPopulatorTestInstance populator=createMockBuilder(AmbariLdapDataPopulatorTestInstance.class).addMockedMethod("getLdapUsers").withConstructor(configuration,users).createNiceMock();
LdapUserDto externalUser1=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser2=createNiceMock(LdapUserDto.class);
LdapUserDto externalUser3=createNiceMock(LdapUserDto.class);
expect(externalUser1.getUserName()).andReturn("user1").anyTimes();
expect(externalUser2.getUserName()).andReturn("user2").anyTimes();
expect(externalUser3.getUserName()).andReturn("user6").anyTimes();
replay(externalUser2,externalUser3,externalUser1);
expect(populator.getLdapUsers("user1")).andReturn(Collections.singleton(externalUser1));
expect(populator.getLdapUsers("user2")).andReturn(Collections.singleton(externalUser2));
expect(populator.getLdapUsers("user6")).andReturn(Collections.singleton(externalUser3));
replay(populator);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
LdapBatchDto result=populator.synchronizeLdapUsers(createSet("user2","user1","user6"),new LdapBatchDto());
assertEquals(2,result.getUsersToBecomeLdap().size());
assertTrue(result.getUsersToBecomeLdap().contains("user1"));
assertTrue(result.getUsersToBecomeLdap().contains("user6"));
assertTrue(result.getUsersToBeCreated().isEmpty());
assertTrue(result.getUsersToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeRemoved().isEmpty());
assertTrue(result.getGroupsToBeCreated().isEmpty());
assertTrue(result.getGroupsToBecomeLdap().isEmpty());
assertTrue(result.getMembershipToAdd().isEmpty());
assertTrue(result.getMembershipToRemove().isEmpty());
verify(populator.loadLdapTemplate(),populator);
}
InternalCallVerifier BooleanVerifier anyObject(),EasyMock.anyObject(),EasyMock.anyObject())).andThrow(new NullPointerException()).once();
replay(ldapTemplate,configuration,ldapServerProperties);
final AmbariLdapDataPopulatorTestInstance populator=new AmbariLdapDataPopulatorTestInstance(configuration,users);
populator.setLdapTemplate(ldapTemplate);
populator.setLdapServerProperties(ldapServerProperties);
assertFalse(populator.isLdapEnabled());
verify(populator.loadLdapTemplate(),configuration);
}
InternalCallVerifier EqualityVerifier contextMapperCapture=new Capture();
Capture searchControlsCapture=new Capture();
PagedResultsDirContextProcessor processor=createNiceMock(PagedResultsDirContextProcessor.class);
PagedResultsCookie cookie=createNiceMock(PagedResultsCookie.class);
LdapUserDto dto=new LdapUserDto();
List list=new LinkedList();
list.add(dto);
expect(configuration.getLdapServerProperties()).andReturn(ldapServerProperties).anyTimes();
expect(ldapServerProperties.isPaginationEnabled()).andReturn(false).anyTimes();
expect(ldapServerProperties.getUserObjectClass()).andReturn("objectClass").anyTimes();
expect(ldapServerProperties.getUsernameAttribute()).andReturn("uid").anyTimes();
expect(ldapServerProperties.getDnAttribute()).andReturn("dn").anyTimes();
expect(ldapServerProperties.getBaseDN()).andReturn("baseDN").anyTimes();
expect(ldapTemplate.search(eq("baseDN"),eq("(&(objectClass=objectClass)(uid=foo))"),anyObject(SearchControls.class),capture(contextMapperCapture))).andReturn(list);
replay(ldapTemplate,ldapServerProperties,users,configuration,processor,cookie);
AmbariLdapDataPopulatorTestInstance populator=new AmbariLdapDataPopulatorTestInstance(configuration,users);
populator.setLdapTemplate(ldapTemplate);
populator.setProcessor(processor);
assertEquals(dto,populator.getLdapUserByMemberAttr("foo"));
verify(ldapTemplate,ldapServerProperties,users,configuration,processor,cookie);
}
InternalCallVerifier EqualityVerifier contextMapperCapture=new Capture();
Capture searchControlsCapture=new Capture();
PagedResultsDirContextProcessor processor=createNiceMock(PagedResultsDirContextProcessor.class);
PagedResultsCookie cookie=createNiceMock(PagedResultsCookie.class);
LdapUserDto dto=new LdapUserDto();
List list=new LinkedList();
list.add(dto);
expect(configuration.getLdapServerProperties()).andReturn(ldapServerProperties).anyTimes();
expect(ldapServerProperties.isPaginationEnabled()).andReturn(true).anyTimes();
expect(ldapServerProperties.getUserObjectClass()).andReturn("objectClass").anyTimes();
expect(ldapServerProperties.getDnAttribute()).andReturn("dn").anyTimes();
expect(ldapServerProperties.getBaseDN()).andReturn("baseDN").anyTimes();
expect(ldapServerProperties.getUsernameAttribute()).andReturn("uid").anyTimes();
expect(processor.getCookie()).andReturn(cookie).anyTimes();
expect(cookie.getCookie()).andReturn(null).anyTimes();
expect(ldapTemplate.search(eq("baseDN"),eq("(&(objectClass=objectClass)(uid=foo))"),anyObject(SearchControls.class),capture(contextMapperCapture),eq(processor))).andReturn(list);
replay(ldapTemplate,ldapServerProperties,users,configuration,processor,cookie);
AmbariLdapDataPopulatorTestInstance populator=new AmbariLdapDataPopulatorTestInstance(configuration,users);
populator.setLdapTemplate(ldapTemplate);
populator.setProcessor(processor);
assertEquals(dto,populator.getLdapUserByMemberAttr("foo"));
verify(ldapTemplate,ldapServerProperties,users,configuration,processor,cookie);
}
Class: org.apache.ambari.server.serveraction.ActionLogTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.serveraction.ServerActionExecutorTest InternalCallVerifier EqualityVerifier emptyMap(),null,null,1200,false,false);
final List stages=new ArrayList(){
{
add(stage);
}
}
;
ActionDBAccessor db=createMockActionDBAccessor(request,stages);
ServerActionExecutor.init(injector);
ServerActionExecutor executor=new ServerActionExecutor(db,10000);
stage.getHostRoleCommand(SERVER_HOST_NAME,Role.AMBARI_SERVER_ACTION.toString()).setStatus(HostRoleStatus.QUEUED);
int cycleCount=0;
while (!getTaskStatus(stage).isHoldingState() && (cycleCount++ <= MAX_CYCLE_ITERATIONS)) {
executor.doWork();
}
assertEquals(HostRoleStatus.HOLDING,getTaskStatus(stage));
}
InternalCallVerifier EqualityVerifier (){
{
put(MockServerAction.PAYLOAD_FORCE_FAIL,"timeout");
}
}
,"test",1);
final List stages=new ArrayList(){
{
add(s);
}
}
;
ActionDBAccessor db=createMockActionDBAccessor(request,stages);
ServerActionExecutor.init(injector);
ServerActionExecutor executor=new ServerActionExecutor(db,10000);
s.getHostRoleCommand(SERVER_HOST_NAME,Role.AMBARI_SERVER_ACTION.toString()).setStatus(HostRoleStatus.QUEUED);
int cycleCount=0;
while (!getTaskStatus(s).isCompletedState() && (cycleCount++ <= MAX_CYCLE_ITERATIONS)) {
executor.doWork();
}
assertEquals(HostRoleStatus.TIMEDOUT,getTaskStatus(s));
}
InternalCallVerifier EqualityVerifier (){
{
put(MockServerAction.PAYLOAD_FORCE_FAIL,"exception");
}
}
,"test",1);
final List stages=new ArrayList(){
{
add(s);
}
}
;
ActionDBAccessor db=createMockActionDBAccessor(request,stages);
ServerActionExecutor.init(injector);
ServerActionExecutor executor=new ServerActionExecutor(db,10000);
s.getHostRoleCommand(SERVER_HOST_NAME,Role.AMBARI_SERVER_ACTION.toString()).setStatus(HostRoleStatus.QUEUED);
int cycleCount=0;
while (!getTaskStatus(s).isCompletedState() && (cycleCount++ <= MAX_CYCLE_ITERATIONS)) {
executor.doWork();
}
assertEquals(HostRoleStatus.FAILED,getTaskStatus(s));
}
InternalCallVerifier EqualityVerifier (){
{
put(MockServerAction.PAYLOAD_FORCE_FAIL,"report");
}
}
,"test",1);
final List stages=new ArrayList(){
{
add(s);
}
}
;
ActionDBAccessor db=createMockActionDBAccessor(request,stages);
ServerActionExecutor.init(injector);
ServerActionExecutor executor=new ServerActionExecutor(db,10000);
s.getHostRoleCommand(SERVER_HOST_NAME,Role.AMBARI_SERVER_ACTION.toString()).setStatus(HostRoleStatus.QUEUED);
int cycleCount=0;
while (!getTaskStatus(s).isCompletedState() && (cycleCount++ <= MAX_CYCLE_ITERATIONS)) {
executor.doWork();
}
assertEquals(HostRoleStatus.FAILED,getTaskStatus(s));
}
InternalCallVerifier EqualityVerifier stages=new ArrayList(){
{
add(s);
}
}
;
ActionDBAccessor db=createMockActionDBAccessor(request,stages);
ServerActionExecutor.init(injector);
ServerActionExecutor executor=new ServerActionExecutor(db,10000);
s.getHostRoleCommand(SERVER_HOST_NAME,Role.AMBARI_SERVER_ACTION.toString()).setStatus(HostRoleStatus.QUEUED);
int cycleCount=0;
while (!getTaskStatus(s).isCompletedState() && (cycleCount++ <= MAX_CYCLE_ITERATIONS)) {
executor.doWork();
}
assertEquals(HostRoleStatus.COMPLETED,getTaskStatus(s));
}
Class: org.apache.ambari.server.serveraction.kerberos.ADKerberosOperationHandlerTest IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier kerberosEnvMap=new HashMap(){
{
put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL,DEFAULT_LDAP_URL);
put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN,DEFAULT_PRINCIPAL_CONTAINER_DN);
put(ADKerberosOperationHandler.KERBEROS_ENV_AD_CREATE_ATTRIBUTES_TEMPLATE,"" + "#set( $user = \"${principal_primary}-${principal_digest}\" )" + "{"+ " \"objectClass\": ["+ " \"top\","+ " \"person\","+ " \"organizationalPerson\","+ " \"user\""+ " ],"+ " \"cn\": \"$user\","+ " \"sAMAccountName\": \"$user.substring(0,20)\","+ " #if( $is_service )"+ " \"servicePrincipalName\": \"$principal_name\","+ " #end"+ " \"userPrincipalName\": \"$normalized_principal\","+ " \"unicodePwd\": \"$password\","+ " \"accountExpires\": \"0\","+ " \"userAccountControl\": \"66048\""+ "}");
}
}
;
Capture capturedName=new Capture();
Capture capturedAttributes=new Capture();
ADKerberosOperationHandler handler=createMockBuilder(ADKerberosOperationHandler.class).addMockedMethod(ADKerberosOperationHandler.class.getDeclaredMethod("createInitialLdapContext",Properties.class,Control[].class)).addMockedMethod(ADKerberosOperationHandler.class.getDeclaredMethod("createSearchControls")).createNiceMock();
NamingEnumeration searchResult=createNiceMock(NamingEnumeration.class);
expect(searchResult.hasMore()).andReturn(false).once();
LdapContext ldapContext=createNiceMock(LdapContext.class);
expect(ldapContext.search(anyObject(String.class),anyObject(String.class),anyObject(SearchControls.class))).andReturn(searchResult).once();
expect(ldapContext.createSubcontext(capture(capturedName),capture(capturedAttributes))).andReturn(createNiceMock(DirContext.class)).once();
expect(handler.createInitialLdapContext(anyObject(Properties.class),anyObject(Control[].class))).andReturn(ldapContext).once();
expect(handler.createSearchControls()).andAnswer(new IAnswer(){
@Override public SearchControls answer() throws Throwable {
SearchControls searchControls=createNiceMock(SearchControls.class);
replay(searchControls);
return searchControls;
}
}
).once();
replayAll();
handler.open(kc,DEFAULT_REALM,kerberosEnvMap);
handler.createPrincipal("nn/c6501.ambari.apache.org","secret",true);
handler.close();
Attributes attributes=capturedAttributes.getValue();
String[] objectClasses=new String[]{"top","person","organizationalPerson","user"};
Assert.assertNotNull(attributes);
Assert.assertEquals(8,attributes.size());
Assert.assertNotNull(attributes.get("objectClass"));
Assert.assertEquals(objectClasses.length,attributes.get("objectClass").size());
for (int i=0; i < objectClasses.length; i++) {
Assert.assertEquals(objectClasses[i],attributes.get("objectClass").get(i));
}
Assert.assertNotNull(attributes.get("cn"));
Assert.assertEquals("nn-995e1580db28198e7fda1417ab5d894c877937d2",attributes.get("cn").get());
Assert.assertNotNull(attributes.get("servicePrincipalName"));
Assert.assertEquals("nn/c6501.ambari.apache.org",attributes.get("servicePrincipalName").get());
Assert.assertNotNull(attributes.get("userPrincipalName"));
Assert.assertEquals("nn/c6501.ambari.apache.org@HDP01.LOCAL",attributes.get("userPrincipalName").get());
Assert.assertNotNull(attributes.get("sAMAccountName"));
Assert.assertTrue(attributes.get("sAMAccountName").get().toString().length() <= 20);
Assert.assertEquals("nn-995e1580db28198e7",attributes.get("sAMAccountName").get());
Assert.assertNotNull(attributes.get("unicodePwd"));
Assert.assertEquals("\"secret\"",new String((byte[])attributes.get("unicodePwd").get(),Charset.forName("UTF-16LE")));
Assert.assertNotNull(attributes.get("accountExpires"));
Assert.assertEquals("0",attributes.get("accountExpires").get());
Assert.assertNotNull(attributes.get("userAccountControl"));
Assert.assertEquals("66048",attributes.get("userAccountControl").get());
}
APIUtilityVerifier IterativeVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier kerberosEnvMap=new HashMap(){
{
put(ADKerberosOperationHandler.KERBEROS_ENV_LDAP_URL,DEFAULT_LDAP_URL);
put(ADKerberosOperationHandler.KERBEROS_ENV_PRINCIPAL_CONTAINER_DN,DEFAULT_PRINCIPAL_CONTAINER_DN);
}
}
;
Capture capturedName=new Capture(CaptureType.ALL);
Capture capturedAttributes=new Capture(CaptureType.ALL);
ADKerberosOperationHandler handler=createMockBuilder(ADKerberosOperationHandler.class).addMockedMethod(ADKerberosOperationHandler.class.getDeclaredMethod("createInitialLdapContext",Properties.class,Control[].class)).addMockedMethod(ADKerberosOperationHandler.class.getDeclaredMethod("createSearchControls")).createNiceMock();
NamingEnumeration searchResult=createNiceMock(NamingEnumeration.class);
expect(searchResult.hasMore()).andReturn(false).once();
LdapContext ldapContext=createNiceMock(LdapContext.class);
expect(ldapContext.search(anyObject(String.class),anyObject(String.class),anyObject(SearchControls.class))).andReturn(searchResult).once();
expect(ldapContext.createSubcontext(capture(capturedName),capture(capturedAttributes))).andReturn(createNiceMock(DirContext.class)).anyTimes();
expect(handler.createInitialLdapContext(anyObject(Properties.class),anyObject(Control[].class))).andReturn(ldapContext).once();
expect(handler.createSearchControls()).andAnswer(new IAnswer(){
@Override public SearchControls answer() throws Throwable {
SearchControls searchControls=createNiceMock(SearchControls.class);
replay(searchControls);
return searchControls;
}
}
).once();
replayAll();
handler.open(kc,DEFAULT_REALM,kerberosEnvMap);
handler.createPrincipal("nn/c6501.ambari.apache.org","secret",true);
handler.createPrincipal("hdfs@" + DEFAULT_REALM,"secret",false);
handler.close();
List attributesList=capturedAttributes.getValues();
Attributes attributes;
attributes=attributesList.get(0);
String[] objectClasses=new String[]{"top","person","organizationalPerson","user"};
Assert.assertNotNull(attributes);
Assert.assertEquals(7,attributes.size());
Assert.assertNotNull(attributes.get("objectClass"));
Assert.assertEquals(objectClasses.length,attributes.get("objectClass").size());
for (int i=0; i < objectClasses.length; i++) {
Assert.assertEquals(objectClasses[i],attributes.get("objectClass").get(i));
}
Assert.assertNotNull(attributes.get("cn"));
Assert.assertEquals("nn/c6501.ambari.apache.org",attributes.get("cn").get());
Assert.assertNotNull(attributes.get("servicePrincipalName"));
Assert.assertEquals("nn/c6501.ambari.apache.org",attributes.get("servicePrincipalName").get());
Assert.assertNotNull(attributes.get("userPrincipalName"));
Assert.assertEquals("nn/c6501.ambari.apache.org@HDP01.LOCAL",attributes.get("userPrincipalName").get());
Assert.assertNotNull(attributes.get("unicodePwd"));
Assert.assertEquals("\"secret\"",new String((byte[])attributes.get("unicodePwd").get(),Charset.forName("UTF-16LE")));
Assert.assertNotNull(attributes.get("accountExpires"));
Assert.assertEquals("0",attributes.get("accountExpires").get());
Assert.assertNotNull(attributes.get("userAccountControl"));
Assert.assertEquals("66048",attributes.get("userAccountControl").get());
attributes=attributesList.get(1);
Assert.assertNotNull(attributes);
Assert.assertEquals(6,attributes.size());
Assert.assertNotNull(attributes.get("objectClass"));
Assert.assertEquals(objectClasses.length,attributes.get("objectClass").size());
for (int i=0; i < objectClasses.length; i++) {
Assert.assertEquals(objectClasses[i],attributes.get("objectClass").get(i));
}
Assert.assertNotNull(attributes.get("cn"));
Assert.assertEquals("hdfs",attributes.get("cn").get());
Assert.assertNotNull(attributes.get("userPrincipalName"));
Assert.assertEquals("hdfs@HDP01.LOCAL",attributes.get("userPrincipalName").get());
Assert.assertNotNull(attributes.get("unicodePwd"));
Assert.assertEquals("\"secret\"",new String((byte[])attributes.get("unicodePwd").get(),Charset.forName("UTF-16LE")));
Assert.assertNotNull(attributes.get("accountExpires"));
Assert.assertEquals("0",attributes.get("accountExpires").get());
Assert.assertNotNull(attributes.get("userAccountControl"));
Assert.assertEquals("66048",attributes.get("userAccountControl").get());
}
Class: org.apache.ambari.server.serveraction.kerberos.CreateKeytabFilesServerActionTest APIUtilityVerifier InternalCallVerifier BooleanVerifier AssumptionSetter EqualityVerifier NullVerifier HybridVerifier permissions;
File directory=testFolder.newFolder();
Assert.assertNotNull(directory);
new CreateKeytabFilesServerAction().ensureAmbariOnlyAccess(directory);
path=Paths.get(directory.getAbsolutePath());
Assert.assertNotNull(path);
permissions=Files.getPosixFilePermissions(path);
Assert.assertNotNull(permissions);
Assert.assertNotNull(permissions);
Assert.assertEquals(3,permissions.size());
Assert.assertTrue(permissions.contains(PosixFilePermission.OWNER_READ));
Assert.assertTrue(permissions.contains(PosixFilePermission.OWNER_WRITE));
Assert.assertTrue(permissions.contains(PosixFilePermission.OWNER_EXECUTE));
Assert.assertFalse(permissions.contains(PosixFilePermission.GROUP_READ));
Assert.assertFalse(permissions.contains(PosixFilePermission.GROUP_WRITE));
Assert.assertFalse(permissions.contains(PosixFilePermission.GROUP_EXECUTE));
Assert.assertFalse(permissions.contains(PosixFilePermission.OTHERS_READ));
Assert.assertFalse(permissions.contains(PosixFilePermission.OTHERS_WRITE));
Assert.assertFalse(permissions.contains(PosixFilePermission.OTHERS_EXECUTE));
File file=File.createTempFile("temp_","",directory);
Assert.assertNotNull(file);
Assert.assertTrue(file.exists());
new CreateKeytabFilesServerAction().ensureAmbariOnlyAccess(file);
path=Paths.get(file.getAbsolutePath());
Assert.assertNotNull(path);
permissions=Files.getPosixFilePermissions(path);
Assert.assertNotNull(permissions);
Assert.assertEquals(2,permissions.size());
Assert.assertTrue(permissions.contains(PosixFilePermission.OWNER_READ));
Assert.assertTrue(permissions.contains(PosixFilePermission.OWNER_WRITE));
Assert.assertFalse(permissions.contains(PosixFilePermission.OWNER_EXECUTE));
Assert.assertFalse(permissions.contains(PosixFilePermission.GROUP_READ));
Assert.assertFalse(permissions.contains(PosixFilePermission.GROUP_WRITE));
Assert.assertFalse(permissions.contains(PosixFilePermission.GROUP_EXECUTE));
Assert.assertFalse(permissions.contains(PosixFilePermission.OTHERS_READ));
Assert.assertFalse(permissions.contains(PosixFilePermission.OTHERS_WRITE));
Assert.assertFalse(permissions.contains(PosixFilePermission.OTHERS_EXECUTE));
}
Class: org.apache.ambari.server.serveraction.kerberos.DeconstructedPrincipalTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.serveraction.kerberos.KerberosConfigDataFileTest APIUtilityVerifier IterativeVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > iterator=reader.iterator();
Assert.assertNotNull(iterator);
int i=0;
while (iterator.hasNext()) {
Map record=iterator.next();
if (i < 15) {
Assert.assertEquals("config-type" + i,record.get(KerberosConfigDataFileReader.CONFIGURATION_TYPE));
Assert.assertEquals("key" + i,record.get(KerberosConfigDataFileReader.KEY));
Assert.assertEquals("value" + i,record.get(KerberosConfigDataFileReader.VALUE));
if (i < 10) {
Assert.assertEquals("SET",record.get(KerberosConfigDataFileReader.OPERATION));
}
else {
Assert.assertEquals("REMOVE",record.get(KerberosConfigDataFileReader.OPERATION));
}
}
i++;
}
Assert.assertEquals(15,i);
reader.close();
Assert.assertTrue(reader.isClosed());
reader.open();
Assert.assertFalse(reader.isClosed());
i=0;
for ( Map record : reader) {
if (i < 10) {
Assert.assertEquals("config-type" + i,record.get(KerberosConfigDataFileReader.CONFIGURATION_TYPE));
Assert.assertEquals("key" + i,record.get(KerberosConfigDataFileReader.KEY));
Assert.assertEquals("value" + i,record.get(KerberosConfigDataFileReader.VALUE));
}
i++;
}
Assert.assertEquals(15,i);
reader.close();
Assert.assertTrue(reader.isClosed());
writer.open();
Assert.assertFalse(writer.isClosed());
writer.addRecord("config-type","key","value",KerberosConfigDataFileReader.OPERATION_TYPE_SET);
writer.close();
Assert.assertTrue(writer.isClosed());
reader=kerberosConfigDataFileReaderFactory.createKerberosConfigDataFileReader(file);
Assert.assertFalse(reader.isClosed());
i=0;
for ( Map record : reader) {
i++;
}
Assert.assertEquals(16,i);
reader.close();
Assert.assertTrue(reader.isClosed());
writer=kerberosConfigDataFileWriterFactory.createKerberosConfigDataFileWriter(file);
Assert.assertFalse(writer.isClosed());
writer.addRecord("config-type","key","value",KerberosConfigDataFileReader.OPERATION_TYPE_REMOVE);
writer.close();
Assert.assertTrue(writer.isClosed());
reader.open();
Assert.assertFalse(reader.isClosed());
i=0;
for ( Map record : reader) {
i++;
}
Assert.assertEquals(17,i);
reader.close();
Assert.assertTrue(reader.isClosed());
i=0;
for ( Map record : reader) {
i++;
}
Assert.assertEquals(0,i);
}
Class: org.apache.ambari.server.serveraction.kerberos.KerberosIdentityDataFileTest APIUtilityVerifier IterativeVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier ","\"keytabFileGroupName\"","keytab,File,Group,Access","false");
writer.close();
Assert.assertTrue(writer.isClosed());
KerberosIdentityDataFileReader reader=kerberosIdentityDataFileReaderFactory.createKerberosIdentityDataFileReader(file);
Assert.assertFalse(reader.isClosed());
Iterator> iterator=reader.iterator();
Assert.assertNotNull(iterator);
int i=0;
while (iterator.hasNext()) {
Map record=iterator.next();
if (i < 10) {
Assert.assertEquals("hostName" + i,record.get(KerberosIdentityDataFileReader.HOSTNAME));
Assert.assertEquals("serviceName" + i,record.get(KerberosIdentityDataFileReader.SERVICE));
Assert.assertEquals("serviceComponentName" + i,record.get(KerberosIdentityDataFileReader.COMPONENT));
Assert.assertEquals("principal" + i,record.get(KerberosIdentityDataFileReader.PRINCIPAL));
Assert.assertEquals("principal_type" + i,record.get(KerberosIdentityDataFileReader.PRINCIPAL_TYPE));
Assert.assertEquals("keytabFilePath" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_PATH));
Assert.assertEquals("keytabFileOwnerName" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_OWNER_NAME));
Assert.assertEquals("keytabFileOwnerAccess" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_OWNER_ACCESS));
Assert.assertEquals("keytabFileGroupName" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_GROUP_NAME));
Assert.assertEquals("keytabFileGroupAccess" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_GROUP_ACCESS));
Assert.assertEquals("false",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_IS_CACHABLE));
}
else {
Assert.assertEquals("hostName's",record.get(KerberosIdentityDataFileReader.HOSTNAME));
Assert.assertEquals("serviceName#",record.get(KerberosIdentityDataFileReader.SERVICE));
Assert.assertEquals("serviceComponentName\"",record.get(KerberosIdentityDataFileReader.COMPONENT));
Assert.assertEquals("principal",record.get(KerberosIdentityDataFileReader.PRINCIPAL));
Assert.assertEquals("principal_type",record.get(KerberosIdentityDataFileReader.PRINCIPAL_TYPE));
Assert.assertEquals("keytabFilePath",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_PATH));
Assert.assertEquals("'keytabFileOwnerName'",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_OWNER_NAME));
Assert.assertEquals("",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_OWNER_ACCESS));
Assert.assertEquals("\"keytabFileGroupName\"",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_GROUP_NAME));
Assert.assertEquals("keytab,File,Group,Access",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_GROUP_ACCESS));
Assert.assertEquals("false",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_IS_CACHABLE));
}
i++;
}
reader.close();
Assert.assertTrue(reader.isClosed());
reader.open();
Assert.assertFalse(reader.isClosed());
i=0;
for ( Map record : reader) {
if (i < 10) {
Assert.assertEquals("hostName" + i,record.get(KerberosIdentityDataFileReader.HOSTNAME));
Assert.assertEquals("serviceName" + i,record.get(KerberosIdentityDataFileReader.SERVICE));
Assert.assertEquals("serviceComponentName" + i,record.get(KerberosIdentityDataFileReader.COMPONENT));
Assert.assertEquals("principal" + i,record.get(KerberosIdentityDataFileReader.PRINCIPAL));
Assert.assertEquals("principal_type" + i,record.get(KerberosIdentityDataFileReader.PRINCIPAL_TYPE));
Assert.assertEquals("keytabFilePath" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_PATH));
Assert.assertEquals("keytabFileOwnerName" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_OWNER_NAME));
Assert.assertEquals("keytabFileOwnerAccess" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_OWNER_ACCESS));
Assert.assertEquals("keytabFileGroupName" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_GROUP_NAME));
Assert.assertEquals("keytabFileGroupAccess" + i,record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_GROUP_ACCESS));
}
else {
Assert.assertEquals("hostName's",record.get(KerberosIdentityDataFileReader.HOSTNAME));
Assert.assertEquals("serviceName#",record.get(KerberosIdentityDataFileReader.SERVICE));
Assert.assertEquals("serviceComponentName\"",record.get(KerberosIdentityDataFileReader.COMPONENT));
Assert.assertEquals("principal",record.get(KerberosIdentityDataFileReader.PRINCIPAL));
Assert.assertEquals("principal_type",record.get(KerberosIdentityDataFileReader.PRINCIPAL_TYPE));
Assert.assertEquals("keytabFilePath",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_PATH));
Assert.assertEquals("'keytabFileOwnerName'",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_OWNER_NAME));
Assert.assertEquals("",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_OWNER_ACCESS));
Assert.assertEquals("\"keytabFileGroupName\"",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_GROUP_NAME));
Assert.assertEquals("keytab,File,Group,Access",record.get(KerberosIdentityDataFileReader.KEYTAB_FILE_GROUP_ACCESS));
}
i++;
}
reader.close();
Assert.assertTrue(reader.isClosed());
writer.open();
Assert.assertFalse(writer.isClosed());
writer.writeRecord("hostName","serviceName","serviceComponentName","principal","principal_type","keytabFilePath","keytabFileOwnerName","keytabFileOwnerAccess","keytabFileGroupName","keytabFileGroupAccess","true");
writer.close();
Assert.assertTrue(writer.isClosed());
reader=kerberosIdentityDataFileReaderFactory.createKerberosIdentityDataFileReader(file);
Assert.assertFalse(reader.isClosed());
i=0;
for ( Map record : reader) {
i++;
}
Assert.assertEquals(12,i);
reader.close();
Assert.assertTrue(reader.isClosed());
writer=kerberosIdentityDataFileWriterFactory.createKerberosIdentityDataFileWriter(file);
Assert.assertFalse(writer.isClosed());
writer.writeRecord("hostName","serviceName","serviceComponentName","principal","principal_type","keytabFilePath","keytabFileOwnerName","keytabFileOwnerAccess","keytabFileGroupName","keytabFileGroupAccess","true");
writer.close();
Assert.assertTrue(writer.isClosed());
reader.open();
Assert.assertFalse(reader.isClosed());
i=0;
for ( Map record : reader) {
i++;
}
Assert.assertEquals(13,i);
reader.close();
Assert.assertTrue(reader.isClosed());
i=0;
for ( Map record : reader) {
i++;
}
Assert.assertEquals(0,i);
}
Class: org.apache.ambari.server.serveraction.kerberos.KerberosOperationHandlerTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier entries=keytab.getEntries();
Assert.assertNotNull(entries);
Assert.assertFalse(entries.isEmpty());
for ( KeytabEntry entry : entries) {
Assert.assertEquals(principal,entry.getPrincipalName());
}
}
finally {
if (!f.delete()) {
f.deleteOnExit();
}
}
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier entries=keytab.getEntries();
Assert.assertNotNull(entries);
Assert.assertFalse(entries.isEmpty());
count=entries.size();
for ( KeytabEntry entry : entries) {
Assert.assertEquals(principal1,entry.getPrincipalName());
}
Assert.assertTrue(handler.createKeytabFile(principal2,"some password",0,file));
keytab=Keytab.read(file);
Assert.assertNotNull(keytab);
entries=keytab.getEntries();
Assert.assertNotNull(entries);
Assert.assertFalse(entries.isEmpty());
Assert.assertEquals(count * 2,entries.size());
}
InternalCallVerifier EqualityVerifier (){
{
add(EncryptionType.AES256_CTS_HMAC_SHA1_96);
add(EncryptionType.AES128_CTS_HMAC_SHA1_96);
add(EncryptionType.DES3_CBC_SHA1_KD);
add(EncryptionType.DES_CBC_MD5);
add(EncryptionType.DES_CBC_MD4);
add(EncryptionType.DES_CBC_CRC);
add(EncryptionType.UNKNOWN);
}
}
,handler.translateEncryptionTypes("aes256-cts-hmac-sha1-96\n aes128-cts-hmac-sha1-96\tdes3-cbc-sha1 arcfour-hmac-md5 " + "camellia256-cts-cmac camellia128-cts-cmac des-cbc-crc des-cbc-md5 des-cbc-md4","\\s+"));
Assert.assertEquals(new HashSet(){
{
add(EncryptionType.AES256_CTS_HMAC_SHA1_96);
add(EncryptionType.AES128_CTS_HMAC_SHA1_96);
}
}
,handler.translateEncryptionTypes("aes"," "));
Assert.assertEquals(new HashSet(){
{
add(EncryptionType.AES256_CTS_HMAC_SHA1_96);
}
}
,handler.translateEncryptionTypes("aes-256"," "));
Assert.assertEquals(new HashSet(){
{
add(EncryptionType.DES3_CBC_SHA1_KD);
}
}
,handler.translateEncryptionTypes("des3"," "));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier specialCharacters=new HashSet(){
{
add('/');
add(',');
add('\\');
add('#');
add('+');
add('<');
add('>');
add(';');
add('"');
add('=');
add(' ');
}
}
;
Assert.assertEquals("\\/\\,\\\\\\#\\+\\<\\>\\;\\\"\\=\\ ",handler.escapeCharacters("/,\\#+<>;\"= ",specialCharacters,'\\'));
Assert.assertNull(handler.escapeCharacters(null,specialCharacters,'\\'));
Assert.assertEquals("",handler.escapeCharacters("",specialCharacters,'\\'));
Assert.assertEquals("nothing_special_here",handler.escapeCharacters("nothing_special_here",specialCharacters,'\\'));
Assert.assertEquals("\\/\\,\\\\\\#\\+\\<\\>\\;\\\"\\=\\ ",handler.escapeCharacters("/,\\#+<>;\"= ",specialCharacters,'\\'));
Assert.assertEquals("nothing<>special#here!",handler.escapeCharacters("nothing<>special#here!",null,'\\'));
Assert.assertEquals("nothing<>special#here!",handler.escapeCharacters("nothing<>special#here!",Collections.emptySet(),'\\'));
Assert.assertEquals("nothing<>special#here!",handler.escapeCharacters("nothing<>special#here!",Collections.singleton('?'),'\\'));
Assert.assertEquals("\\A's are special!",handler.escapeCharacters("A's are special!",Collections.singleton('A'),'\\'));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier seenEntries=new HashSet();
Assert.assertTrue(handler.createKeytabFile(principal1,"some password",0,file));
Assert.assertTrue(handler.createKeytabFile(principal2,"some password",0,file));
Assert.assertTrue(handler.createKeytabFile(principal2,"some password",0,file));
Keytab keytab=Keytab.read(file);
Assert.assertNotNull(keytab);
List entries=keytab.getEntries();
Assert.assertNotNull(entries);
Assert.assertFalse(entries.isEmpty());
for ( KeytabEntry entry : entries) {
String seenEntry=String.format("%s|%s",entry.getPrincipalName(),entry.getKey().getKeyType().toString());
Assert.assertFalse(seenEntries.contains(seenEntry));
seenEntries.add(seenEntry);
}
}
InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.serveraction.kerberos.KerberosServerActionTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier sharedMap=new ConcurrentHashMap();
sharedMap.put("FAIL","true");
CommandReport report=action.processIdentities(sharedMap);
Assert.assertNotNull(report);
Assert.assertEquals(HostRoleStatus.FAILED.toString(),report.getStatus());
verify(kerberosHelper);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier sharedMap=new ConcurrentHashMap();
CommandReport report=action.processIdentities(sharedMap);
Assert.assertNotNull(report);
Assert.assertEquals(HostRoleStatus.COMPLETED.toString(),report.getStatus());
for ( Map.Entry entry : sharedMap.entrySet()) {
Assert.assertEquals(entry.getValue(),entry.getKey().replace("_HOST","hostName").replace("_REALM","REALM.COM"));
}
verify(kerberosHelper);
}
Class: org.apache.ambari.server.serveraction.kerberos.MITKerberosOperationHandlerTest InternalCallVerifier BooleanVerifier (){
@Override public ShellCommandUtil.Result answer() throws Throwable {
ShellCommandUtil.Result result=createMock(ShellCommandUtil.Result.class);
expect(result.getExitCode()).andReturn(0).anyTimes();
expect(result.isSuccessful()).andReturn(true).anyTimes();
expect(result.getStderr()).andReturn("get_principal: Principal does not exist while retrieving \"admin/admi@EXAMPLE.COM\".").anyTimes();
expect(result.getStdout()).andReturn("Authenticating as principal admin/admin with password.").anyTimes();
replay(result);
return result;
}
}
);
replayAll();
handler.open(new PrincipalKeyCredential(DEFAULT_ADMIN_PRINCIPAL,DEFAULT_ADMIN_PASSWORD),DEFAULT_REALM,KERBEROS_ENV_MAP);
Assert.assertFalse(handler.testAdministratorCredentials());
handler.close();
}
Class: org.apache.ambari.server.serveraction.upgrades.AutoSkipFailedSummaryActionTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier groupUpgradeItems=new ArrayList(){
{
add(upgradeItem1);
add(upgradeItem2);
}
}
;
upgradeGroupEntity.setItems(groupUpgradeItems);
UpgradeItemEntity upgradeItemEntity=new UpgradeItemEntity();
upgradeItemEntity.setGroupEntity(upgradeGroupEntity);
expect(upgradeDAOMock.findUpgradeItemByRequestAndStage(anyLong(),anyLong())).andReturn(upgradeItemEntity).anyTimes();
expect(upgradeDAOMock.findUpgradeGroup(anyLong())).andReturn(upgradeGroupEntity).anyTimes();
replay(upgradeDAOMock);
List skippedTasks=new ArrayList(){
{
add(createSkippedTask("DATANODE","DATANODE","host1.vm","RESTART HDFS/DATANODE",RoleCommand.CUSTOM_COMMAND,"RESTART"));
add(createSkippedTask("DATANODE","DATANODE","host2.vm","RESTART HDFS/DATANODE",RoleCommand.CUSTOM_COMMAND,"RESTART"));
}
}
;
expect(hostRoleCommandDAOMock.findByStatusBetweenStages(anyLong(),anyObject(HostRoleStatus.class),anyLong(),anyLong())).andReturn(skippedTasks).anyTimes();
replay(hostRoleCommandDAOMock);
ConcurrentMap requestSharedDataContext=new ConcurrentHashMap();
CommandReport result=action.execute(requestSharedDataContext);
assertNotNull(result.getStructuredOut());
assertEquals(0,result.getExitCode());
assertEquals(HostRoleStatus.HOLDING.toString(),result.getStatus());
assertEquals("There were 2 skipped failure(s) that must be addressed " + "before you can proceed. Please resolve each failure before continuing with the upgrade.",result.getStdOut());
assertEquals("{\"failures\":" + "{\"host_component\":" + "{\"host1.vm\":[{\"component\":\"DATANODE\",\"service\":\"HDFS\"}],"+ "\"host2.vm\":[{\"component\":\"DATANODE\",\"service\":\"HDFS\"}]}},"+ "\"skipped\":[\"host_component\"]}",result.getStructuredOut());
assertEquals("The following steps failed but were automatically skipped:\n" + "DATANODE on host1.vm: RESTART HDFS/DATANODE\n" + "DATANODE on host2.vm: RESTART HDFS/DATANODE\n",result.getStdErr());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier groupUpgradeItems=new ArrayList(){
{
add(upgradeItem1);
add(upgradeItem2);
}
}
;
upgradeGroupEntity.setItems(groupUpgradeItems);
UpgradeItemEntity upgradeItemEntity=new UpgradeItemEntity();
upgradeItemEntity.setGroupEntity(upgradeGroupEntity);
expect(upgradeDAOMock.findUpgradeItemByRequestAndStage(anyLong(),anyLong())).andReturn(upgradeItemEntity).anyTimes();
expect(upgradeDAOMock.findUpgradeGroup(anyLong())).andReturn(upgradeGroupEntity).anyTimes();
replay(upgradeDAOMock);
List skippedTasks=new ArrayList(){
{
add(createSkippedTask("DATANODE","DATANODE","host1.vm","RESTART HDFS/DATANODE",RoleCommand.CUSTOM_COMMAND,"RESTART"));
add(createSkippedTask("DATANODE","DATANODE","host2.vm","RESTART HDFS/DATANODE",RoleCommand.CUSTOM_COMMAND,"RESTART"));
add(createSkippedTask("ZOOKEEPER_QUORUM_SERVICE_CHECK","ZOOKEEPER_CLIENT","host2.vm","SERVICE_CHECK ZOOKEEPER",RoleCommand.SERVICE_CHECK,null));
}
}
;
expect(hostRoleCommandDAOMock.findByStatusBetweenStages(anyLong(),anyObject(HostRoleStatus.class),anyLong(),anyLong())).andReturn(skippedTasks).anyTimes();
replay(hostRoleCommandDAOMock);
ConcurrentMap requestSharedDataContext=new ConcurrentHashMap();
CommandReport result=action.execute(requestSharedDataContext);
assertNotNull(result.getStructuredOut());
assertEquals(0,result.getExitCode());
assertEquals(HostRoleStatus.HOLDING.toString(),result.getStatus());
assertEquals("There were 3 skipped failure(s) that must be addressed " + "before you can proceed. Please resolve each failure before continuing with the upgrade.",result.getStdOut());
assertEquals("{\"failures\":" + "{\"service_check\":[\"ZOOKEEPER\"]," + "\"host_component\":{"+ "\"host1.vm\":[{\"component\":\"DATANODE\",\"service\":\"HDFS\"}],"+ "\"host2.vm\":[{\"component\":\"DATANODE\",\"service\":\"HDFS\"}]}},"+ "\"skipped\":[\"service_check\",\"host_component\"]}",result.getStructuredOut());
assertEquals("The following steps failed but were automatically skipped:\n" + "DATANODE on host1.vm: RESTART HDFS/DATANODE\n" + "DATANODE on host2.vm: RESTART HDFS/DATANODE\n"+ "ZOOKEEPER_CLIENT on host2.vm: SERVICE_CHECK ZOOKEEPER\n",result.getStdErr());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier groupUpgradeItems=new ArrayList(){
{
add(upgradeItem1);
add(upgradeItem2);
}
}
;
upgradeGroupEntity.setItems(groupUpgradeItems);
UpgradeItemEntity upgradeItemEntity=new UpgradeItemEntity();
upgradeItemEntity.setGroupEntity(upgradeGroupEntity);
expect(upgradeDAOMock.findUpgradeItemByRequestAndStage(anyLong(),anyLong())).andReturn(upgradeItemEntity).anyTimes();
expect(upgradeDAOMock.findUpgradeGroup(anyLong())).andReturn(upgradeGroupEntity).anyTimes();
replay(upgradeDAOMock);
List skippedTasks=new ArrayList(){
{
}
}
;
expect(hostRoleCommandDAOMock.findByStatusBetweenStages(anyLong(),anyObject(HostRoleStatus.class),anyLong(),anyLong())).andReturn(skippedTasks).anyTimes();
replay(hostRoleCommandDAOMock);
ConcurrentMap requestSharedDataContext=new ConcurrentHashMap();
CommandReport result=action.execute(requestSharedDataContext);
assertNotNull(result.getStructuredOut());
assertEquals(0,result.getExitCode());
assertEquals(HostRoleStatus.COMPLETED.toString(),result.getStatus());
assertEquals("There were no skipped failures",result.getStdOut());
assertEquals("{}",result.getStructuredOut());
assertEquals("",result.getStdErr());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier groupUpgradeItems=new ArrayList(){
{
add(upgradeItem1);
add(upgradeItem2);
}
}
;
upgradeGroupEntity.setItems(groupUpgradeItems);
UpgradeItemEntity upgradeItemEntity=new UpgradeItemEntity();
upgradeItemEntity.setGroupEntity(upgradeGroupEntity);
expect(upgradeDAOMock.findUpgradeItemByRequestAndStage(anyLong(),anyLong())).andReturn(upgradeItemEntity).anyTimes();
expect(upgradeDAOMock.findUpgradeGroup(anyLong())).andReturn(upgradeGroupEntity).anyTimes();
replay(upgradeDAOMock);
List skippedTasks=new ArrayList(){
{
add(createSkippedTask("ZOOKEEPER_QUORUM_SERVICE_CHECK","ZOOKEEPER_CLIENT","host2.vm","SERVICE_CHECK ZOOKEEPER",RoleCommand.SERVICE_CHECK,null));
}
}
;
expect(hostRoleCommandDAOMock.findByStatusBetweenStages(anyLong(),anyObject(HostRoleStatus.class),anyLong(),anyLong())).andReturn(skippedTasks).anyTimes();
replay(hostRoleCommandDAOMock);
ConcurrentMap requestSharedDataContext=new ConcurrentHashMap();
CommandReport result=action.execute(requestSharedDataContext);
assertNotNull(result.getStructuredOut());
assertEquals(0,result.getExitCode());
assertEquals(HostRoleStatus.HOLDING.toString(),result.getStatus());
assertEquals("There were 1 skipped failure(s) that must be addressed " + "before you can proceed. Please resolve each failure before continuing with the upgrade.",result.getStdOut());
assertEquals("{\"failures\":{\"service_check\":[\"ZOOKEEPER\"]},\"skipped\":[\"service_check\"]}",result.getStructuredOut());
assertEquals("The following steps failed but were automatically skipped:\n" + "ZOOKEEPER_CLIENT on host2.vm: SERVICE_CHECK ZOOKEEPER\n",result.getStdErr());
}
Class: org.apache.ambari.server.serveraction.upgrades.ComponentVersionCheckActionTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier hostVersions=hostVersionDAO.findByClusterStackAndVersion("c1",HDP_22_STACK,targetRepo);
assertEquals(RepositoryVersionState.UPGRADING,upgradingClusterVersion.getState());
assertTrue(hostVersions.size() > 0);
for ( HostVersionEntity hostVersion : hostVersions) {
assertEquals(RepositoryVersionState.UPGRADED,hostVersion.getState());
}
Map commandParams=new HashMap();
commandParams.put(FinalizeUpgradeAction.UPGRADE_DIRECTION_KEY,"upgrade");
commandParams.put(FinalizeUpgradeAction.VERSION_KEY,targetRepo);
commandParams.put(FinalizeUpgradeAction.ORIGINAL_STACK_KEY,sourceStack.getStackId());
commandParams.put(FinalizeUpgradeAction.TARGET_STACK_KEY,targetStack.getStackId());
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
ComponentVersionCheckAction action=m_injector.getInstance(ComponentVersionCheckAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.FAILED.name(),report.getStatus());
assertEquals(-1,report.getExitCode());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier commandParams=new HashMap();
commandParams.put(FinalizeUpgradeAction.UPGRADE_DIRECTION_KEY,"upgrade");
commandParams.put(FinalizeUpgradeAction.VERSION_KEY,targetRepo);
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
ComponentVersionCheckAction action=m_injector.getInstance(ComponentVersionCheckAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.COMPLETED.name(),report.getStatus());
assertEquals(0,report.getExitCode());
}
Class: org.apache.ambari.server.serveraction.upgrades.ConfigureActionTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("initLimit","10");
}
}
,new HashMap>());
config.setTag("version2");
config.persist();
c.addConfig(config);
c.addDesiredConfig("user",Collections.singleton(config));
assertEquals(2,c.getConfigsByType("zoo.cfg").size());
List configurations=new ArrayList();
ConfigurationKeyValue keyValue=new ConfigurationKeyValue();
configurations.add(keyValue);
keyValue.key="initLimit";
keyValue.value="11";
Map commandParams=new HashMap();
commandParams.put("upgrade_direction","upgrade");
commandParams.put("version",HDP_2_2_0_1);
commandParams.put("clusterName","c1");
commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE,"zoo.cfg");
commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS,new Gson().toJson(configurations));
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
ConfigureAction action=m_injector.getInstance(ConfigureAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(2,c.getConfigsByType("zoo.cfg").size());
config=c.getDesiredConfigByType("zoo.cfg");
assertNotNull(config);
assertEquals("version2",config.getTag());
assertEquals("11",config.getProperties().get("initLimit"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("zoo.server.csv","c6401,c6402, c6403");
}
}
,new HashMap>());
config.setTag("version2");
config.persist();
c.addConfig(config);
c.addDesiredConfig("user",Collections.singleton(config));
assertEquals(2,c.getConfigsByType("zoo.cfg").size());
Map commandParams=new HashMap();
commandParams.put("upgrade_direction","upgrade");
commandParams.put("version",HDP_2_2_0_1);
commandParams.put("clusterName","c1");
commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE,"zoo.cfg");
List transfers=new ArrayList();
Transfer transfer=new Transfer();
transfer.operation=TransferOperation.COPY;
transfer.coerceTo=TransferCoercionType.YAML_ARRAY;
transfer.fromKey="zoo.server.csv";
transfer.toKey="zoo.server.array";
transfer.defaultValue="['foo','bar']";
transfers.add(transfer);
commandParams.put(ConfigureTask.PARAMETER_TRANSFERS,new Gson().toJson(transfers));
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
executionCommand.setRoleParams(new HashMap());
executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME,"username");
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
ConfigureAction action=m_injector.getInstance(ConfigureAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(3,c.getConfigsByType("zoo.cfg").size());
config=c.getDesiredConfigByType("zoo.cfg");
assertNotNull(config);
assertFalse("version2".equals(config.getTag()));
Map map=config.getProperties();
assertEquals("c6401,c6402, c6403",map.get("zoo.server.csv"));
assertEquals("['c6401','c6402','c6403']",map.get("zoo.server.array"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("tickTime","2000");
put("foo","bar");
}
}
,new HashMap>());
config.setTag("version2");
config.persist();
c.addConfig(config);
c.addDesiredConfig("user",Collections.singleton(config));
assertEquals(2,c.getConfigsByType("zoo.cfg").size());
Map commandParams=new HashMap();
commandParams.put("upgrade_direction","upgrade");
commandParams.put("version",HDP_2_2_0_1);
commandParams.put("clusterName","c1");
commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE,"zoo.cfg");
List transfers=new ArrayList<>();
Transfer transfer=new Transfer();
transfer.operation=TransferOperation.DELETE;
transfer.deleteKey="*";
transfer.preserveEdits=true;
transfers.add(transfer);
commandParams.put(ConfigureTask.PARAMETER_TRANSFERS,new Gson().toJson(transfers));
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
executionCommand.setRoleParams(new HashMap());
executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME,"username");
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
ConfigureAction action=m_injector.getInstance(ConfigureAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(3,c.getConfigsByType("zoo.cfg").size());
config=c.getDesiredConfigByType("zoo.cfg");
assertNotNull(config);
assertFalse("version2".equals(config.getTag()));
Map map=config.getProperties();
assertEquals("bar",map.get("foo"));
assertFalse(map.containsKey("tickTime"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("initLimit","10");
put("copyIt","10");
put("moveIt","10");
put("deleteIt","10");
}
}
,new HashMap>());
config.setTag("version2");
config.persist();
c.addConfig(config);
c.addDesiredConfig("user",Collections.singleton(config));
assertEquals(2,c.getConfigsByType("zoo.cfg").size());
List configurations=new ArrayList<>();
ConfigurationKeyValue keyValue=new ConfigurationKeyValue();
configurations.add(keyValue);
keyValue.key="initLimit";
keyValue.value="11";
Map commandParams=new HashMap();
commandParams.put("upgrade_direction","upgrade");
commandParams.put("version",HDP_2_2_0_1);
commandParams.put("clusterName","c1");
commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE,"zoo.cfg");
commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS,new Gson().toJson(configurations));
List transfers=new ArrayList<>();
Transfer transfer=new Transfer();
transfer.operation=TransferOperation.COPY;
transfer.fromKey="copyIt";
transfer.toKey="copyKey";
transfers.add(transfer);
transfer=new Transfer();
transfer.operation=TransferOperation.COPY;
transfer.fromKey="copiedFromMissingKeyWithDefault";
transfer.toKey="copiedToMissingKeyWithDefault";
transfer.defaultValue="defaultValue";
transfers.add(transfer);
transfer=new Transfer();
transfer.operation=TransferOperation.MOVE;
transfer.fromKey="moveIt";
transfer.toKey="movedKey";
transfers.add(transfer);
transfer=new Transfer();
transfer.operation=TransferOperation.MOVE;
transfer.fromKey="movedFromKeyMissingWithDefault";
transfer.toKey="movedToMissingWithDefault";
transfer.defaultValue="defaultValue2";
transfer.mask=true;
transfers.add(transfer);
transfer=new Transfer();
transfer.operation=TransferOperation.DELETE;
transfer.deleteKey="deleteIt";
transfers.add(transfer);
commandParams.put(ConfigureTask.PARAMETER_TRANSFERS,new Gson().toJson(transfers));
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
executionCommand.setRoleParams(new HashMap());
executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME,"username");
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
ConfigureAction action=m_injector.getInstance(ConfigureAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(3,c.getConfigsByType("zoo.cfg").size());
config=c.getDesiredConfigByType("zoo.cfg");
assertNotNull(config);
assertFalse("version2".equals(config.getTag()));
Map map=config.getProperties();
assertEquals("11",map.get("initLimit"));
assertEquals("10",map.get("copyIt"));
assertTrue(map.containsKey("copyKey"));
assertEquals(map.get("copyIt"),map.get("copyKey"));
assertFalse(map.containsKey("moveIt"));
assertTrue(map.containsKey("movedKey"));
assertFalse(map.containsKey("deletedKey"));
assertTrue(map.containsKey("copiedToMissingKeyWithDefault"));
assertEquals("defaultValue",map.get("copiedToMissingKeyWithDefault"));
assertTrue(map.containsKey("movedToMissingWithDefault"));
assertEquals("defaultValue2",map.get("movedToMissingWithDefault"));
transfers.clear();
transfer=new Transfer();
transfer.operation=TransferOperation.DELETE;
transfer.deleteKey="*";
transfer.preserveEdits=true;
transfer.keepKeys.add("copyKey");
transfer.keepKeys.add("keyNotExisting");
transfer.keepKeys.add(null);
transfers.add(transfer);
commandParams.put(ConfigureTask.PARAMETER_TRANSFERS,new Gson().toJson(transfers));
report=action.execute(null);
assertNotNull(report);
assertEquals(4,c.getConfigsByType("zoo.cfg").size());
config=c.getDesiredConfigByType("zoo.cfg");
map=config.getProperties();
assertEquals(6,map.size());
assertTrue(map.containsKey("initLimit"));
assertTrue(map.containsKey("copyKey"));
assertFalse(map.containsKey("keyNotExisting"));
assertFalse(map.containsKey(null));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("fooKey","barValue");
}
}
,new HashMap>());
config.setTag("version2");
config.persist();
c.addConfig(config);
c.addDesiredConfig("user",Collections.singleton(config));
assertEquals(2,c.getConfigsByType("zoo.cfg").size());
List configurations=new ArrayList();
ConfigurationKeyValue fooKey2=new ConfigurationKeyValue();
configurations.add(fooKey2);
fooKey2.key="fooKey2";
fooKey2.value="barValue2";
ConfigurationKeyValue fooKey3=new ConfigurationKeyValue();
configurations.add(fooKey3);
fooKey3.key="fooKey3";
fooKey3.value="barValue3";
fooKey3.mask=true;
Map commandParams=new HashMap();
commandParams.put("upgrade_direction","upgrade");
commandParams.put("version",HDP_2_2_0_1);
commandParams.put("clusterName","c1");
commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE,"zoo.cfg");
commandParams.put(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS,new Gson().toJson(configurations));
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
ConfigureAction action=m_injector.getInstance(ConfigureAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(2,c.getConfigsByType("zoo.cfg").size());
config=c.getDesiredConfigByType("zoo.cfg");
assertNotNull(config);
assertEquals("barValue",config.getProperties().get("fooKey"));
assertEquals("barValue2",config.getProperties().get("fooKey2"));
assertEquals("barValue3",config.getProperties().get("fooKey3"));
assertTrue(report.getStdOut().contains("******"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("key_to_replace","My New Cat");
put("key_with_no_match","WxyAndZ");
}
}
,new HashMap>());
config.setTag("version2");
config.persist();
c.addConfig(config);
c.addDesiredConfig("user",Collections.singleton(config));
assertEquals(2,c.getConfigsByType("zoo.cfg").size());
Map commandParams=new HashMap();
commandParams.put("upgrade_direction","upgrade");
commandParams.put("version",HDP_2_2_0_1);
commandParams.put("clusterName","c1");
commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE,"zoo.cfg");
List replacements=new ArrayList();
Replace replace=new Replace();
replace.key="key_to_replace";
replace.find="New Cat";
replace.replaceWith="Wet Dog";
replacements.add(replace);
replace=new Replace();
replace.key="key_with_no_match";
replace.find="abc";
replace.replaceWith="def";
replacements.add(replace);
commandParams.put(ConfigureTask.PARAMETER_REPLACEMENTS,new Gson().toJson(replacements));
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
executionCommand.setRoleParams(new HashMap());
executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME,"username");
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
ConfigureAction action=m_injector.getInstance(ConfigureAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(3,c.getConfigsByType("zoo.cfg").size());
config=c.getDesiredConfigByType("zoo.cfg");
assertNotNull(config);
assertFalse("version2".equals(config.getTag()));
assertEquals("My Wet Dog",config.getProperties().get("key_to_replace"));
assertEquals("WxyAndZ",config.getProperties().get("key_with_no_match"));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("existing","This exists!");
put("missing",null);
}
}
,new HashMap>());
config.setTag("version2");
config.persist();
c.addConfig(config);
c.addDesiredConfig("user",Collections.singleton(config));
assertEquals(2,c.getConfigsByType("zoo.cfg").size());
Map commandParams=new HashMap();
commandParams.put("upgrade_direction","upgrade");
commandParams.put("version",HDP_2_2_0_1);
commandParams.put("clusterName","c1");
commandParams.put(ConfigureTask.PARAMETER_CONFIG_TYPE,"zoo.cfg");
List replacements=new ArrayList();
Replace replace=new Replace();
replace.key="missing";
replace.find="foo";
replace.replaceWith="bar";
replacements.add(replace);
commandParams.put(ConfigureTask.PARAMETER_REPLACEMENTS,new Gson().toJson(replacements));
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
executionCommand.setRoleParams(new HashMap());
executionCommand.getRoleParams().put(ServerAction.ACTION_USER_NAME,"username");
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
ConfigureAction action=m_injector.getInstance(ConfigureAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(3,c.getConfigsByType("zoo.cfg").size());
config=c.getDesiredConfigByType("zoo.cfg");
assertEquals(null,config.getProperties().get("missing"));
}
Class: org.apache.ambari.server.serveraction.upgrades.RangerConfigCalculationTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier commandParams=new HashMap();
commandParams.put("clusterName","c1");
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
HostRoleCommand hrc=EasyMock.createMock(HostRoleCommand.class);
expect(hrc.getRequestId()).andReturn(1L).anyTimes();
expect(hrc.getStageId()).andReturn(2L).anyTimes();
expect(hrc.getExecutionCommandWrapper()).andReturn(new ExecutionCommandWrapper(executionCommand)).anyTimes();
replay(hrc);
RangerConfigCalculation action=new RangerConfigCalculation();
m_clusterField.set(action,m_clusters);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hrc);
CommandReport report=action.execute(null);
assertNotNull(report);
Cluster c=m_clusters.getCluster("c1");
Config config=c.getDesiredConfigByType("ranger-admin-site");
Map map=config.getProperties();
assertTrue(map.containsKey("ranger.jpa.jdbc.driver"));
assertTrue(map.containsKey("ranger.jpa.jdbc.url"));
assertTrue(map.containsKey("ranger.jpa.jdbc.dialect"));
assertTrue(map.containsKey("ranger.jpa.audit.jdbc.driver"));
assertTrue(map.containsKey("ranger.jpa.audit.jdbc.url"));
assertTrue(map.containsKey("ranger.jpa.audit.jdbc.dialect"));
assertEquals("com.mysql.jdbc.Driver",map.get("ranger.jpa.jdbc.driver"));
assertEquals("jdbc:mysql://host1/ranger",map.get("ranger.jpa.jdbc.url"));
assertEquals("org.eclipse.persistence.platform.database.MySQLPlatform",map.get("ranger.jpa.jdbc.dialect"));
assertEquals("com.mysql.jdbc.Driver",map.get("ranger.jpa.audit.jdbc.driver"));
assertEquals("jdbc:mysql://host1/ranger_audit",map.get("ranger.jpa.audit.jdbc.url"));
assertEquals("org.eclipse.persistence.platform.database.MySQLPlatform",map.get("ranger.jpa.audit.jdbc.dialect"));
config=c.getDesiredConfigByType("admin-properties");
config.getProperties().put("DB_FLAVOR","oracle");
report=action.execute(null);
assertNotNull(report);
config=c.getDesiredConfigByType("ranger-admin-site");
map=config.getProperties();
assertEquals("oracle.jdbc.OracleDriver",map.get("ranger.jpa.jdbc.driver"));
assertEquals("jdbc:oracle:thin:@//host1",map.get("ranger.jpa.jdbc.url"));
assertEquals("org.eclipse.persistence.platform.database.OraclePlatform",map.get("ranger.jpa.jdbc.dialect"));
assertEquals("oracle.jdbc.OracleDriver",map.get("ranger.jpa.audit.jdbc.driver"));
assertEquals("jdbc:oracle:thin:@//host1",map.get("ranger.jpa.audit.jdbc.url"));
assertEquals("org.eclipse.persistence.platform.database.OraclePlatform",map.get("ranger.jpa.audit.jdbc.dialect"));
}
Class: org.apache.ambari.server.serveraction.upgrades.SparkShufflePropertyConfigTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier commandParams=new HashMap<>();
HostRoleCommand hrc=EasyMock.createMock(HostRoleCommand.class);
SparkShufflePropertyConfig action=new SparkShufflePropertyConfig();
commandParams.put("clusterName","c1");
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName("c1");
expect(hrc.getRequestId()).andReturn(1L).anyTimes();
expect(hrc.getStageId()).andReturn(2L).anyTimes();
expect(hrc.getExecutionCommandWrapper()).andReturn(new ExecutionCommandWrapper(executionCommand)).anyTimes();
replay(cluster,hrc);
clusterField.set(action,m_clusters);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hrc);
CommandReport report=action.execute(null);
assertNotNull(report);
Cluster c=m_clusters.getCluster("c1");
Config config=c.getDesiredConfigByType("yarn-site");
Map map=config.getProperties();
assertTrue(map.containsKey("yarn.nodemanager.aux-services"));
assertTrue(map.containsKey("yarn.nodemanager.aux-services.spark_shuffle.class"));
assertEquals("some_service,spark_shuffle",map.get("yarn.nodemanager.aux-services"));
assertEquals("org.apache.spark.network.yarn.YarnShuffleService",map.get("yarn.nodemanager.aux-services.spark_shuffle.class"));
}
Class: org.apache.ambari.server.serveraction.upgrades.UpgradeActionTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier hostVersions=hostVersionDAO.findByClusterStackAndVersion(clusterName,HDP_22_STACK,targetRepo);
assertEquals(RepositoryVersionState.UPGRADING,upgradingClusterVersion.getState());
assertTrue(hostVersions.size() > 0);
for ( HostVersionEntity hostVersion : hostVersions) {
assertEquals(RepositoryVersionState.UPGRADED,hostVersion.getState());
}
Map commandParams=new HashMap();
commandParams.put(FinalizeUpgradeAction.UPGRADE_DIRECTION_KEY,"upgrade");
commandParams.put(FinalizeUpgradeAction.VERSION_KEY,targetRepo);
commandParams.put(FinalizeUpgradeAction.ORIGINAL_STACK_KEY,sourceStack.getStackId());
commandParams.put(FinalizeUpgradeAction.TARGET_STACK_KEY,targetStack.getStackId());
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName(clusterName);
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
FinalizeUpgradeAction action=m_injector.getInstance(FinalizeUpgradeAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.COMPLETED.name(),report.getStatus());
StackId currentStackId=cluster.getCurrentStackVersion();
StackId desiredStackId=cluster.getDesiredStackVersion();
assertEquals(desiredStackId,currentStackId);
assertEquals(targetStack,currentStackId);
assertEquals(targetStack,desiredStackId);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier configs=cluster.getAllConfigs();
assertEquals(8,configs.size());
Map commandParams=new HashMap();
commandParams.put(FinalizeUpgradeAction.UPGRADE_DIRECTION_KEY,"downgrade");
commandParams.put(FinalizeUpgradeAction.VERSION_KEY,sourceRepo);
commandParams.put(FinalizeUpgradeAction.ORIGINAL_STACK_KEY,sourceStack.getStackId());
commandParams.put(FinalizeUpgradeAction.TARGET_STACK_KEY,targetStack.getStackId());
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName(clusterName);
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
HostVersionDAO dao=m_injector.getInstance(HostVersionDAO.class);
List hosts=dao.findByClusterStackAndVersion(clusterName,targetStack,targetRepo);
assertFalse(hosts.isEmpty());
for ( HostVersionEntity hve : hosts) {
assertFalse(hve.getState() == RepositoryVersionState.INSTALLED);
}
FinalizeUpgradeAction action=m_injector.getInstance(FinalizeUpgradeAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.COMPLETED.name(),report.getStatus());
StackId currentStackId=cluster.getCurrentStackVersion();
StackId desiredStackId=cluster.getDesiredStackVersion();
assertEquals(desiredStackId,currentStackId);
assertEquals(sourceStack,currentStackId);
assertEquals(sourceStack,desiredStackId);
cluster=clusters.getCluster(clusterName);
configs=cluster.getAllConfigs();
assertEquals(4,configs.size());
hosts=dao.findByClusterStackAndVersion(clusterName,targetStack,targetRepo);
assertFalse(hosts.isEmpty());
for ( HostVersionEntity hve : hosts) {
assertTrue(hve.getState() == RepositoryVersionState.INSTALLED);
}
}
BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier commandParams=new HashMap();
commandParams.put(FinalizeUpgradeAction.UPGRADE_DIRECTION_KEY,"downgrade");
commandParams.put(FinalizeUpgradeAction.VERSION_KEY,sourceRepo);
commandParams.put(FinalizeUpgradeAction.ORIGINAL_STACK_KEY,sourceStack.getStackId());
commandParams.put(FinalizeUpgradeAction.TARGET_STACK_KEY,targetStack.getStackId());
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName(clusterName);
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
FinalizeUpgradeAction action=m_injector.getInstance(FinalizeUpgradeAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.COMPLETED.name(),report.getStatus());
for ( HostVersionEntity entity : hostVersionDAO.findByClusterAndHost(clusterName,"h1")) {
if (entity.getRepositoryVersion().getVersion().equals(sourceRepo)) {
assertEquals(RepositoryVersionState.CURRENT,entity.getState());
}
else if (entity.getRepositoryVersion().getVersion().equals(targetRepo)) {
assertEquals(RepositoryVersionState.INSTALLED,entity.getState());
}
}
for ( ClusterVersionEntity entity : clusterVersionDAO.findByCluster(clusterName)) {
if (entity.getRepositoryVersion().getVersion().equals(sourceRepo)) {
assertEquals(RepositoryVersionState.CURRENT,entity.getState());
}
else if (entity.getRepositoryVersion().getVersion().equals(targetRepo)) {
assertEquals(RepositoryVersionState.INSTALLED,entity.getState());
}
}
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier commandParams=new HashMap();
commandParams.put(FinalizeUpgradeAction.UPGRADE_DIRECTION_KEY,"upgrade");
commandParams.put(FinalizeUpgradeAction.VERSION_KEY,targetRepo);
commandParams.put(FinalizeUpgradeAction.ORIGINAL_STACK_KEY,sourceStack.getStackId());
commandParams.put(FinalizeUpgradeAction.TARGET_STACK_KEY,targetStack.getStackId());
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName(clusterName);
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
FinalizeUpgradeAction action=m_injector.getInstance(FinalizeUpgradeAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.COMPLETED.name(),report.getStatus());
StackId currentStackId=cluster.getCurrentStackVersion();
StackId desiredStackId=cluster.getDesiredStackVersion();
assertEquals(desiredStackId,currentStackId);
assertEquals(targetStack,currentStackId);
assertEquals(targetStack,desiredStackId);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier packs=metaInfo.getUpgradePacks(sourceStack.getStackName(),sourceStack.getStackVersion());
Assert.assertTrue(packs.containsKey(upgradePackName));
makeCrossStackUpgradeCluster(sourceStack,sourceRepo,targetStack,targetRepo);
RepositoryVersionEntity targetRve=repoVersionDAO.findByStackNameAndVersion("HDP",targetRepo);
Assert.assertNotNull(targetRve);
Cluster cluster=clusters.getCluster(clusterName);
Service zk=installService(cluster,"ZOOKEEPER");
addServiceComponent(cluster,zk,"ZOOKEEPER_SERVER");
addServiceComponent(cluster,zk,"ZOOKEEPER_CLIENT");
createNewServiceComponentHost(cluster,"ZOOKEEPER","ZOOKEEPER_SERVER","h1");
createNewServiceComponentHost(cluster,"ZOOKEEPER","ZOOKEEPER_CLIENT","h1");
Service hdfs=installService(cluster,"HDFS");
addServiceComponent(cluster,hdfs,"NAMENODE");
addServiceComponent(cluster,hdfs,"DATANODE");
createNewServiceComponentHost(cluster,"HDFS","NAMENODE","h1");
createNewServiceComponentHost(cluster,"HDFS","DATANODE","h1");
createConfigs(cluster);
Collection configs=cluster.getAllConfigs();
Assert.assertFalse(configs.isEmpty());
Map commandParams=new HashMap();
commandParams.put(UpdateDesiredStackAction.COMMAND_PARAM_ORIGINAL_STACK,sourceStack.getStackId());
commandParams.put(UpdateDesiredStackAction.COMMAND_PARAM_TARGET_STACK,targetStack.getStackId());
commandParams.put(UpdateDesiredStackAction.COMMAND_PARAM_DIRECTION,Direction.UPGRADE.toString());
commandParams.put(UpdateDesiredStackAction.COMMAND_PARAM_VERSION,targetRepo);
commandParams.put(UpdateDesiredStackAction.COMMAND_PARAM_UPGRADE_PACK,upgradePackName);
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
Map roleParams=new HashMap<>();
String userName="admin";
roleParams.put(ServerAction.ACTION_USER_NAME,userName);
executionCommand.setRoleParams(roleParams);
executionCommand.setClusterName(clusterName);
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
UpdateDesiredStackAction action=m_injector.getInstance(UpdateDesiredStackAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
List configVersionsBefore=cluster.getServiceConfigVersions();
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.COMPLETED.name(),report.getStatus());
List configVersionsAfter=cluster.getServiceConfigVersions();
Assert.assertFalse(configVersionsAfter.isEmpty());
assertTrue(configVersionsAfter.size() - configVersionsBefore.size() >= 1);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier commandParams=new HashMap();
commandParams.put(FinalizeUpgradeAction.UPGRADE_DIRECTION_KEY,"downgrade");
commandParams.put(FinalizeUpgradeAction.VERSION_KEY,midRepo);
commandParams.put(FinalizeUpgradeAction.ORIGINAL_STACK_KEY,sourceStack.getStackId());
commandParams.put(FinalizeUpgradeAction.TARGET_STACK_KEY,targetStack.getStackId());
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName(clusterName);
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
FinalizeUpgradeAction action=m_injector.getInstance(FinalizeUpgradeAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.FAILED.name(),report.getStatus());
assertTrue(report.getStdErr().contains(FinalizeUpgradeAction.PREVIOUS_UPGRADE_NOT_COMPLETED_MSG));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier commandParams=new HashMap();
commandParams.put(FinalizeUpgradeAction.UPGRADE_DIRECTION_KEY,"upgrade");
commandParams.put(FinalizeUpgradeAction.VERSION_KEY,targetRepo);
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName(clusterName);
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
FinalizeUpgradeAction action=m_injector.getInstance(FinalizeUpgradeAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.COMPLETED.name(),report.getStatus());
verifyBaseRepoURL(helper,cluster,host,"http://foo1");
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hostVersions=hostVersionDAO.findAll();
for ( HostVersionEntity hostVersion : hostVersions) {
if (hostVersion.getState() == RepositoryVersionState.CURRENT) {
hostVersion.setState(RepositoryVersionState.INSTALLED);
}
else {
hostVersion.setState(RepositoryVersionState.CURRENT);
}
hostVersionDAO.merge(hostVersion);
}
AmbariMetaInfo metaInfo=m_injector.getInstance(AmbariMetaInfo.class);
AmbariCustomCommandExecutionHelper helper=m_injector.getInstance(AmbariCustomCommandExecutionHelper.class);
Host host=clusters.getHost("h1");
Cluster cluster=clusters.getCluster(clusterName);
RepositoryInfo repo=metaInfo.getRepository(sourceStack.getStackName(),sourceStack.getStackVersion(),"redhat6",sourceStack.getStackId());
assertEquals(HDP_211_CENTOS6_REPO_URL,repo.getBaseUrl());
verifyBaseRepoURL(helper,cluster,host,HDP_211_CENTOS6_REPO_URL);
Map commandParams=new HashMap();
commandParams.put(FinalizeUpgradeAction.UPGRADE_DIRECTION_KEY,"upgrade");
commandParams.put(FinalizeUpgradeAction.VERSION_KEY,targetRepo);
ExecutionCommand executionCommand=new ExecutionCommand();
executionCommand.setCommandParams(commandParams);
executionCommand.setClusterName(clusterName);
HostRoleCommand hostRoleCommand=hostRoleCommandFactory.create(null,null,null,null);
hostRoleCommand.setExecutionCommandWrapper(new ExecutionCommandWrapper(executionCommand));
FinalizeUpgradeAction action=m_injector.getInstance(FinalizeUpgradeAction.class);
action.setExecutionCommand(executionCommand);
action.setHostRoleCommand(hostRoleCommand);
CommandReport report=action.execute(null);
assertNotNull(report);
assertEquals(HostRoleStatus.COMPLETED.name(),report.getStatus());
}
Class: org.apache.ambari.server.stack.ComponentModuleTest InternalCallVerifier EqualityVerifier clientConfigs=new ArrayList();
ClientConfigFileDefinition clientConfig1=new ClientConfigFileDefinition();
clientConfig1.setType("type1");
clientConfig1.setDictionaryName("dictName1");
clientConfig1.setFileName("filename1");
ClientConfigFileDefinition clientConfig2=new ClientConfigFileDefinition();
clientConfig1.setType("type1");
clientConfig1.setDictionaryName("dictName1");
clientConfig1.setFileName("filename1");
clientConfigs.add(clientConfig1);
clientConfigs.add(clientConfig2);
ComponentInfo info=new ComponentInfo();
ComponentInfo parentInfo=new ComponentInfo();
parentInfo.setClientConfigFiles(clientConfigs);
assertEquals(clientConfigs,resolveComponent(info,parentInfo).getModuleInfo().getClientConfigFiles());
info.setClientConfigFiles(clientConfigs);
parentInfo.setClientConfigFiles(null);
assertEquals(clientConfigs,resolveComponent(info,parentInfo).getModuleInfo().getClientConfigFiles());
List clientConfigs2=new ArrayList();
ClientConfigFileDefinition clientConfig3=new ClientConfigFileDefinition();
clientConfig3.setType("type1");
clientConfig3.setDictionaryName("dictName1");
clientConfig3.setFileName("DIFFERENT filename");
clientConfigs2.add(clientConfig3);
info.setClientConfigFiles(clientConfigs2);
parentInfo.setClientConfigFiles(clientConfigs);
assertEquals(clientConfigs2,resolveComponent(info,parentInfo).getModuleInfo().getClientConfigFiles());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier clientsToUpdate=new ArrayList();
String client1="one";
String client2="two";
clientsToUpdate.add(client1);
clientsToUpdate.add(client2);
ComponentInfo info=new ComponentInfo();
ComponentInfo parentInfo=new ComponentInfo();
parentInfo.setClientsToUpdateConfigs(clientsToUpdate);
assertEquals(clientsToUpdate,resolveComponent(info,parentInfo).getModuleInfo().getClientsToUpdateConfigs());
info.setClientsToUpdateConfigs(clientsToUpdate);
parentInfo.setClientsToUpdateConfigs(null);
assertEquals(clientsToUpdate,resolveComponent(info,parentInfo).getModuleInfo().getClientsToUpdateConfigs());
List clientsToUpdate2=new ArrayList();
String client3="two";
String client4="four";
clientsToUpdate2.add(client3);
clientsToUpdate2.add(client4);
info.setClientsToUpdateConfigs(clientsToUpdate2);
parentInfo.setClientsToUpdateConfigs(clientsToUpdate);
List resolvedClientsToUpdate=resolveComponent(info,parentInfo).getModuleInfo().getClientsToUpdateConfigs();
assertEquals(2,resolvedClientsToUpdate.size());
assertTrue(resolvedClientsToUpdate.contains(client3));
assertTrue(resolvedClientsToUpdate.contains(client4));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier IdentityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier dependencies=new ArrayList();
DependencyInfo dependency1=new DependencyInfo();
dependency1.setName("service/one");
DependencyInfo dependency2=new DependencyInfo();
dependency2.setName("service/two");
dependencies.add(dependency1);
dependencies.add(dependency2);
ComponentInfo info=new ComponentInfo();
ComponentInfo parentInfo=new ComponentInfo();
parentInfo.setDependencies(dependencies);
assertEquals(dependencies,resolveComponent(info,parentInfo).getModuleInfo().getDependencies());
info.setDependencies(dependencies);
parentInfo.setDependencies(null);
assertEquals(dependencies,resolveComponent(info,parentInfo).getModuleInfo().getDependencies());
List dependencies2=new ArrayList();
DependencyInfo dependency3=new DependencyInfo();
dependency3.setName("service/two");
DependencyInfo dependency4=new DependencyInfo();
dependency4.setName("service/four");
dependencies2.add(dependency3);
dependencies2.add(dependency4);
info.setDependencies(dependencies2);
parentInfo.setDependencies(dependencies);
List resolvedDependencies=resolveComponent(info,parentInfo).getModuleInfo().getDependencies();
assertEquals(3,resolvedDependencies.size());
assertTrue(resolvedDependencies.contains(dependency1));
assertTrue(resolvedDependencies.contains(dependency3));
assertTrue(resolvedDependencies.contains(dependency4));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier commands=new ArrayList();
CustomCommandDefinition command1=new CustomCommandDefinition();
setPrivateField(command1,"name","one");
CustomCommandDefinition command2=new CustomCommandDefinition();
setPrivateField(command2,"name","two");
commands.add(command1);
commands.add(command2);
ComponentInfo info=new ComponentInfo();
ComponentInfo parentInfo=new ComponentInfo();
parentInfo.setCustomCommands(commands);
assertEquals(commands,resolveComponent(info,parentInfo).getModuleInfo().getCustomCommands());
info.setCustomCommands(commands);
parentInfo.setCustomCommands(null);
assertEquals(commands,resolveComponent(info,parentInfo).getModuleInfo().getCustomCommands());
List commands2=new ArrayList();
CustomCommandDefinition command3=new CustomCommandDefinition();
setPrivateField(command3,"name","two");
CustomCommandDefinition command4=new CustomCommandDefinition();
setPrivateField(command4,"name","four");
commands2.add(command3);
commands2.add(command4);
info.setCustomCommands(commands2);
parentInfo.setCustomCommands(commands);
List resolvedCommands=resolveComponent(info,parentInfo).getModuleInfo().getCustomCommands();
assertEquals(3,resolvedCommands.size());
assertTrue(resolvedCommands.contains(command1));
assertTrue(resolvedCommands.contains(command3));
assertTrue(resolvedCommands.contains(command4));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier dependencies=new ArrayList();
String dependency1="one";
String dependency2="two";
dependencies.add(dependency1);
dependencies.add(dependency2);
ComponentInfo info=new ComponentInfo();
ComponentInfo parentInfo=new ComponentInfo();
parentInfo.setConfigDependencies(dependencies);
assertEquals(dependencies,resolveComponent(info,parentInfo).getModuleInfo().getConfigDependencies());
info.setConfigDependencies(dependencies);
parentInfo.setConfigDependencies(null);
assertEquals(dependencies,resolveComponent(info,parentInfo).getModuleInfo().getConfigDependencies());
List dependencies2=new ArrayList();
String dependency3="two";
String dependency4="four";
dependencies2.add(dependency3);
dependencies2.add(dependency4);
info.setConfigDependencies(dependencies2);
parentInfo.setConfigDependencies(dependencies);
List resolvedDependencies=resolveComponent(info,parentInfo).getModuleInfo().getConfigDependencies();
assertEquals(2,resolvedDependencies.size());
assertTrue(resolvedDependencies.contains(dependency3));
assertTrue(resolvedDependencies.contains(dependency4));
}
Class: org.apache.ambari.server.stack.QuickLinksConfigurationModuleTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier checks=protocol.getChecks();
for ( Check check : checks) {
assertEquals("mapred-site",check.getSite());
}
}
Class: org.apache.ambari.server.stack.ServiceModuleTest APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier osSpecifics=new HashMap();
osSpecifics.put("foo",new ServiceOsSpecific());
ServiceInfo info=new ServiceInfo();
ServiceInfo parentInfo=new ServiceInfo();
info.setOsSpecifics(osSpecifics);
ServiceModule service=resolveService(info,parentInfo);
assertEquals(osSpecifics,service.getModuleInfo().getOsSpecifics());
info.setOsSpecifics(null);
parentInfo.setOsSpecifics(osSpecifics);
service=resolveService(info,parentInfo);
assertEquals(osSpecifics,service.getModuleInfo().getOsSpecifics());
Map osSpecifics2=new HashMap();
osSpecifics.put("bar",new ServiceOsSpecific());
info.setOsSpecifics(osSpecifics);
parentInfo.setOsSpecifics(osSpecifics2);
service=resolveService(info,parentInfo);
assertEquals(osSpecifics,service.getModuleInfo().getOsSpecifics());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier configDependencies=new ArrayList();
configDependencies.add("foo");
configDependencies.add("bar");
ServiceInfo info=new ServiceInfo();
ServiceInfo parentInfo=new ServiceInfo();
info.setConfigDependencies(configDependencies);
ServiceModule service=resolveService(info,parentInfo);
assertEquals(configDependencies,service.getModuleInfo().getConfigDependencies());
info.setConfigDependencies(null);
parentInfo.setConfigDependencies(configDependencies);
service=resolveService(info,parentInfo);
assertEquals(configDependencies,service.getModuleInfo().getConfigDependencies());
List parentCustomCommands=new ArrayList();
parentCustomCommands.add("bar");
parentCustomCommands.add("other");
info.setConfigDependencies(configDependencies);
parentInfo.setConfigDependencies(parentCustomCommands);
service=resolveService(info,parentInfo);
Collection mergedConfigDependencies=service.getModuleInfo().getConfigDependencies();
assertEquals(3,mergedConfigDependencies.size());
assertTrue(mergedConfigDependencies.contains("foo"));
assertTrue(mergedConfigDependencies.contains("bar"));
assertTrue(mergedConfigDependencies.contains("other"));
info.setConfigDependencies(null);
parentInfo.setConfigDependencies(null);
service=resolveService(info,parentInfo);
assertTrue(service.getModuleInfo().getConfigDependencies().isEmpty());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier parentServicePropertyList=Lists.newArrayList(p1,p2);
parentServiceInfo.setServicePropertyList(parentServicePropertyList);
ServiceModule serviceModule=resolveService(serviceInfo,parentServiceInfo);
Map parentServiceProperties=ImmutableMap.builder().put("P1","V1").put("P2","V2").put(ServiceInfo.DEFAULT_SERVICE_INSTALLABLE_PROPERTY).put(ServiceInfo.DEFAULT_SERVICE_MANAGED_PROPERTY).put(ServiceInfo.DEFAULT_SERVICE_MONITORED_PROPERTY).build();
assertEquals(parentServicePropertyList,serviceModule.getModuleInfo().getServicePropertyList());
assertEquals(parentServiceProperties,serviceModule.getModuleInfo().getServiceProperties());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier fooProperties=new ArrayList();
PropertyInfo prop1=new PropertyInfo();
prop1.setName("name1");
prop1.setValue("val1");
fooProperties.add(prop1);
PropertyInfo prop2=new PropertyInfo();
prop2.setName("name2");
prop2.setValue("val2");
fooProperties.add(prop2);
Collection barProperties=new ArrayList();
PropertyInfo prop3=new PropertyInfo();
prop3.setName("name1");
prop3.setValue("val3");
barProperties.add(prop3);
Collection otherProperties=new ArrayList();
PropertyInfo prop4=new PropertyInfo();
prop4.setName("name1");
prop4.setValue("val4");
otherProperties.add(prop4);
ConfigurationModule configModule1=createConfigurationModule("FOO",fooProperties);
ConfigurationModule configModule2=createConfigurationModule("BAR",barProperties);
ConfigurationModule configModule3=createConfigurationModule("OTHER",otherProperties);
Collection configModules=new ArrayList();
configModules.add(configModule1);
configModules.add(configModule2);
configModules.add(configModule3);
ServiceModule service=createServiceModule(info,configModules);
List properties=service.getModuleInfo().getProperties();
assertEquals(4,properties.size());
Map>> attributes=service.getModuleInfo().getConfigTypeAttributes();
assertEquals(2,attributes.size());
assertTrue(attributes.containsKey("FOO"));
assertTrue(attributes.containsKey("OTHER"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier customCommands=new ArrayList();
CustomCommandDefinition cmd1=new CustomCommandDefinition();
setPrivateField(cmd1,"name","cmd1");
setPrivateField(cmd1,"background",false);
CustomCommandDefinition cmd2=new CustomCommandDefinition();
setPrivateField(cmd2,"name","cmd2");
customCommands.add(cmd1);
customCommands.add(cmd2);
ServiceInfo info=new ServiceInfo();
ServiceInfo parentInfo=new ServiceInfo();
info.setCustomCommands(customCommands);
ServiceModule service=resolveService(info,parentInfo);
assertEquals(customCommands,service.getModuleInfo().getCustomCommands());
info.setCustomCommands(null);
parentInfo.setCustomCommands(customCommands);
service=resolveService(info,parentInfo);
assertEquals(customCommands,service.getModuleInfo().getCustomCommands());
List parentCustomCommands=new ArrayList();
CustomCommandDefinition cmd3=new CustomCommandDefinition();
setPrivateField(cmd3,"name","cmd1");
setPrivateField(cmd3,"background",true);
CustomCommandDefinition cmd4=new CustomCommandDefinition();
setPrivateField(cmd4,"name","cmd4");
parentCustomCommands.add(cmd3);
parentCustomCommands.add(cmd4);
info.setCustomCommands(customCommands);
parentInfo.setCustomCommands(parentCustomCommands);
service=resolveService(info,parentInfo);
Collection mergedCommands=service.getModuleInfo().getCustomCommands();
assertEquals(3,mergedCommands.size());
assertTrue(mergedCommands.contains(cmd2));
assertTrue(mergedCommands.contains(cmd3));
assertTrue(mergedCommands.contains(cmd4));
info.setCustomCommands(null);
parentInfo.setCustomCommands(null);
service=resolveService(info,parentInfo);
assertTrue(service.getModuleInfo().getCustomCommands().isEmpty());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier childFooProperties=new ArrayList();
PropertyInfo childProp1=new PropertyInfo();
childProp1.setName("childName1");
childProp1.setValue("childVal1");
childFooProperties.add(childProp1);
Collection childBarProperties=new ArrayList();
PropertyInfo childProp2=new PropertyInfo();
childProp2.setName("childName2");
childProp2.setValue("childVal2");
childBarProperties.add(childProp2);
Map attributes=new HashMap();
attributes.put(ConfigurationInfo.Supports.DO_NOT_EXTEND.getXmlAttributeName(),"true");
ConfigurationModule childConfigModule1=createConfigurationModule("FOO",childFooProperties);
ConfigurationModule childConfigModule2=createConfigurationModule("BAR",childBarProperties,attributes);
Collection childModules=new ArrayList();
childModules.add(childConfigModule1);
childModules.add(childConfigModule2);
Collection parentFooProperties=new ArrayList();
PropertyInfo parentProp1=new PropertyInfo();
parentProp1.setName("parentName1");
parentProp1.setValue("parentVal1");
parentFooProperties.add(parentProp1);
PropertyInfo parentProp12=new PropertyInfo();
parentProp12.setName("childName1");
parentProp12.setValue("parentVal1");
parentFooProperties.add(parentProp12);
Collection parentBarProperties=new ArrayList();
PropertyInfo parentProp2=new PropertyInfo();
parentProp2.setName("parentName2");
parentProp2.setValue("parentVal2");
parentBarProperties.add(parentProp2);
Collection parentOtherProperties=new ArrayList();
PropertyInfo parentProp3=new PropertyInfo();
parentProp3.setName("parentName3");
parentProp3.setValue("parentVal3");
parentOtherProperties.add(parentProp3);
ConfigurationModule parentConfigModule1=createConfigurationModule("FOO",parentFooProperties);
ConfigurationModule parentConfigModule2=createConfigurationModule("BAR",parentBarProperties);
ConfigurationModule parentConfigModule3=createConfigurationModule("OTHER",parentOtherProperties);
Collection parentModules=new ArrayList();
parentModules.add(parentConfigModule1);
parentModules.add(parentConfigModule2);
parentModules.add(parentConfigModule3);
ServiceModule child=createServiceModule(info,childModules);
ServiceModule parent=createServiceModule(parentInfo,parentModules);
resolveService(child,parent);
List mergedProperties=child.getModuleInfo().getProperties();
assertEquals(4,mergedProperties.size());
Map mergedPropertyMap=new HashMap();
for ( PropertyInfo prop : mergedProperties) {
mergedPropertyMap.put(prop.getName(),prop);
}
assertEquals("childVal1",mergedPropertyMap.get("childName1").getValue());
assertEquals("childVal2",mergedPropertyMap.get("childName2").getValue());
assertEquals("parentVal1",mergedPropertyMap.get("parentName1").getValue());
assertEquals("parentVal3",mergedPropertyMap.get("parentName3").getValue());
Map>> childAttributes=child.getModuleInfo().getConfigTypeAttributes();
Map>> parentAttributes=parent.getModuleInfo().getConfigTypeAttributes();
assertEquals(3,childAttributes.size());
assertAttributes(childAttributes.get("FOO"),Collections.emptyMap());
assertAttributes(childAttributes.get("BAR"),attributes);
assertAttributes(childAttributes.get("OTHER"),Collections.emptyMap());
assertEquals(3,parentAttributes.size());
assertAttributes(parentAttributes.get("FOO"),Collections.emptyMap());
assertAttributes(parentAttributes.get("BAR"),Collections.emptyMap());
assertAttributes(parentAttributes.get("OTHER"),Collections.emptyMap());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier fooProperties=new ArrayList();
PropertyInfo prop1=new PropertyInfo();
prop1.setName("name1");
prop1.setValue("val1");
fooProperties.add(prop1);
PropertyInfo prop2=new PropertyInfo();
prop2.setName("name2");
prop2.setValue("val2");
fooProperties.add(prop2);
ConfigurationModule childConfigModule=createConfigurationModule("FOO",fooProperties);
Collection childConfigModules=new ArrayList();
childConfigModules.add(childConfigModule);
ServiceInfo parentInfo=new ServiceInfo();
Collection barProperties=new ArrayList();
PropertyInfo prop3=new PropertyInfo();
prop3.setName("name1");
prop3.setValue("val3");
barProperties.add(prop3);
ConfigurationModule parentConfigModule=createConfigurationModule("BAR",barProperties);
Collection parentConfigModules=new ArrayList();
parentConfigModules.add(parentConfigModule);
ServiceModule service=createServiceModule(info,childConfigModules);
ServiceModule parentService=createServiceModule(parentInfo,parentConfigModules);
resolveService(service,parentService);
List properties=service.getModuleInfo().getProperties();
assertEquals(2,properties.size());
Map>> attributes=service.getModuleInfo().getConfigTypeAttributes();
assertEquals(1,attributes.size());
assertTrue(attributes.containsKey("FOO"));
Map>> parentAttributes=parentService.getModuleInfo().getConfigTypeAttributes();
assertEquals(1,parentAttributes.size());
assertTrue(parentAttributes.containsKey("BAR"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier requiredServices=new ArrayList();
requiredServices.add("foo");
requiredServices.add("bar");
ServiceInfo info=new ServiceInfo();
ServiceInfo parentInfo=new ServiceInfo();
info.setRequiredServices(requiredServices);
ServiceModule service=resolveService(info,parentInfo);
assertEquals(requiredServices,service.getModuleInfo().getRequiredServices());
info.setRequiredServices(null);
parentInfo.setRequiredServices(requiredServices);
service=resolveService(info,parentInfo);
assertEquals(requiredServices,service.getModuleInfo().getRequiredServices());
info.setRequiredServices(requiredServices);
parentInfo.setRequiredServices(Collections.singletonList("other"));
service=resolveService(info,parentInfo);
assertEquals(requiredServices,service.getModuleInfo().getRequiredServices());
info.setRequiredServices(null);
parentInfo.setRequiredServices(null);
service=resolveService(info,parentInfo);
assertTrue(service.getModuleInfo().getRequiredServices().isEmpty());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier parentServicePropertyList=Lists.newArrayList(p1,p2);
parentServiceInfo.setServicePropertyList(parentServicePropertyList);
List servicePropertyList=Lists.newArrayList(p2Override,p3);
serviceInfo.setServicePropertyList(servicePropertyList);
ServiceModule serviceModule=resolveService(serviceInfo,parentServiceInfo);
List expectedPropertyList=Lists.newArrayList(p1,p2Override,p3);
Map expectedServiceProperties=ImmutableMap.builder().put("P1","V1").put("P2","V2_OVERRIDE").put("P3","V3").put(ServiceInfo.DEFAULT_SERVICE_INSTALLABLE_PROPERTY).put(ServiceInfo.DEFAULT_SERVICE_MANAGED_PROPERTY).put(ServiceInfo.DEFAULT_SERVICE_MONITORED_PROPERTY).build();
List actualPropertyList=serviceModule.getModuleInfo().getServicePropertyList();
assertTrue(actualPropertyList.containsAll(expectedPropertyList) && expectedPropertyList.containsAll(actualPropertyList));
assertEquals(expectedServiceProperties,serviceModule.getModuleInfo().getServiceProperties());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier childFooProperties=new ArrayList();
PropertyInfo childProp1=new PropertyInfo();
childProp1.setName("childName1");
childProp1.setValue("childVal1");
childFooProperties.add(childProp1);
Map childFooAttributes=new HashMap();
childFooAttributes.put(ConfigurationInfo.Supports.ADDING_FORBIDDEN.getXmlAttributeName(),"false");
ConfigurationModule childConfigModule1=createConfigurationModule("FOO",childFooProperties,childFooAttributes);
Collection childModules=new ArrayList();
childModules.add(childConfigModule1);
Collection parentFooProperties=new ArrayList();
PropertyInfo parentProp1=new PropertyInfo();
parentProp1.setName("parentName1");
parentProp1.setValue("parentVal1");
parentFooProperties.add(parentProp1);
Map parentFooAttributes=new HashMap();
parentFooAttributes.put(ConfigurationInfo.Supports.FINAL.getXmlAttributeName(),"true");
parentFooAttributes.put(ConfigurationInfo.Supports.ADDING_FORBIDDEN.getXmlAttributeName(),"true");
Collection parentBarProperties=new ArrayList();
PropertyInfo parentProp2=new PropertyInfo();
parentProp2.setName("parentName2");
parentProp2.setValue("parentVal2");
parentBarProperties.add(parentProp2);
ConfigurationModule parentConfigModule1=createConfigurationModule("FOO",parentFooProperties,parentFooAttributes);
ConfigurationModule parentConfigModule2=createConfigurationModule("BAR",parentBarProperties);
Collection parentModules=new ArrayList();
parentModules.add(parentConfigModule1);
parentModules.add(parentConfigModule2);
ServiceModule child=createServiceModule(info,childModules);
ServiceModule parent=createServiceModule(parentInfo,parentModules);
resolveService(child,parent);
Map>> childTypeAttributes=child.getModuleInfo().getConfigTypeAttributes();
Map>> parentTypeAttributes=parent.getModuleInfo().getConfigTypeAttributes();
assertTrue(childTypeAttributes.containsKey("FOO"));
Map> mergedChildFooAttributes=childTypeAttributes.get("FOO");
assertTrue(mergedChildFooAttributes.containsKey(ConfigurationInfo.Supports.KEYWORD));
assertEquals("true",mergedChildFooAttributes.get(ConfigurationInfo.Supports.KEYWORD).get(ConfigurationInfo.Supports.valueOf("FINAL").getPropertyName()));
assertEquals("false",mergedChildFooAttributes.get(ConfigurationInfo.Supports.KEYWORD).get(ConfigurationInfo.Supports.valueOf("ADDING_FORBIDDEN").getPropertyName()));
assertEquals(2,childTypeAttributes.size());
assertEquals(2,parentTypeAttributes.size());
assertAttributes(parentTypeAttributes.get("FOO"),parentFooAttributes);
assertAttributes(parentTypeAttributes.get("BAR"),Collections.emptyMap());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier servicePropertyList=Lists.newArrayList(p1,p2);
serviceInfo.setServicePropertyList(servicePropertyList);
ServiceModule serviceModule=resolveService(serviceInfo,parentServiceInfo);
Map serviceProperties=ImmutableMap.builder().put("P1","V1").put("P2","V2").put(ServiceInfo.DEFAULT_SERVICE_INSTALLABLE_PROPERTY).put(ServiceInfo.DEFAULT_SERVICE_MANAGED_PROPERTY).put(ServiceInfo.DEFAULT_SERVICE_MONITORED_PROPERTY).build();
assertEquals(servicePropertyList,serviceModule.getModuleInfo().getServicePropertyList());
assertEquals(serviceProperties,serviceModule.getModuleInfo().getServiceProperties());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier childComponents=info.getComponents();
childComponents.add(info3);
childComponents.add(info4);
childComponents.add(info5);
List parentComponents=parentInfo.getComponents();
parentComponents.add(info1);
parentComponents.add(info2);
ServiceModule child=createServiceModule(info);
ServiceModule parent=createServiceModule(parentInfo);
resolveService(child,parent);
List components=child.getModuleInfo().getComponents();
assertEquals(3,components.size());
Map mergedComponents=new HashMap();
for ( ComponentInfo component : components) {
mergedComponents.put(component.getName(),component);
}
assertTrue(mergedComponents.containsKey("1"));
assertTrue(mergedComponents.containsKey("2"));
assertTrue(mergedComponents.containsKey("4"));
assertEquals("ALL",mergedComponents.get("1").getCardinality());
assertEquals("category",mergedComponents.get("1").getCategory());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier childExcludedConfigTypes=new HashSet();
childExcludedConfigTypes.add("FOO");
info.setExcludedConfigTypes(childExcludedConfigTypes);
Collection fooProperties=new ArrayList();
ConfigurationModule childConfigModule=createConfigurationModule("FOO",fooProperties);
Collection childConfigModules=new ArrayList();
childConfigModules.add(childConfigModule);
ServiceInfo parentInfo=new ServiceInfo();
Set parentExcludedConfigTypes=new HashSet();
childExcludedConfigTypes.add("BAR");
info.setExcludedConfigTypes(childExcludedConfigTypes);
parentInfo.setExcludedConfigTypes(parentExcludedConfigTypes);
Collection barProperties=new ArrayList();
ConfigurationModule parentConfigModule=createConfigurationModule("BAR",barProperties);
Collection parentConfigModules=new ArrayList();
parentConfigModules.add(parentConfigModule);
ServiceModule service=createServiceModule(info,childConfigModules);
ServiceModule parentService=createServiceModule(parentInfo,parentConfigModules);
resolveService(service,parentService);
assertEquals(2,service.getModuleInfo().getExcludedConfigTypes().size());
}
Class: org.apache.ambari.server.stack.StackManagerCommonServicesTest APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier services=stack.getServices();
assertEquals(3,services.size());
Map serviceMap=new HashMap();
for ( ServiceInfo service : services) {
serviceMap.put(service.getName(),service);
}
ServiceInfo hdfsService=serviceMap.get("HDFS");
assertNotNull(hdfsService);
List components=hdfsService.getComponents();
assertEquals(6,components.size());
List properties=hdfsService.getProperties();
assertEquals(62,properties.size());
boolean hdfsPropFound=false;
boolean hbasePropFound=false;
for ( PropertyInfo p : properties) {
if (p.getName().equals("hbase.regionserver.msginterval")) {
assertEquals("hbase-site.xml",p.getFilename());
hbasePropFound=true;
}
else if (p.getName().equals("dfs.name.dir")) {
assertEquals("hdfs-site.xml",p.getFilename());
hdfsPropFound=true;
}
}
assertTrue(hbasePropFound);
assertTrue(hdfsPropFound);
ServiceInfo mrService=serviceMap.get("MAPREDUCE");
assertNotNull(mrService);
components=mrService.getComponents();
assertEquals(3,components.size());
ServiceInfo pigService=serviceMap.get("PIG");
assertNotNull(pigService);
assertEquals("PIG",pigService.getName());
assertEquals("1.0",pigService.getVersion());
assertEquals("This is comment for PIG service",pigService.getComment());
components=pigService.getComponents();
assertEquals(1,components.size());
CommandScriptDefinition commandScript=pigService.getCommandScript();
assertEquals("scripts/service_check.py",commandScript.getScript());
assertEquals(CommandScriptDefinition.Type.PYTHON,commandScript.getScriptType());
assertEquals(300,commandScript.getTimeout());
List configDependencies=pigService.getConfigDependencies();
assertEquals(1,configDependencies.size());
assertEquals("global",configDependencies.get(0));
assertEquals("global",pigService.getConfigDependenciesWithComponents().get(0));
ComponentInfo client=pigService.getClientComponent();
assertNotNull(client);
assertEquals("PIG",client.getName());
assertEquals("0+",client.getCardinality());
assertEquals("CLIENT",client.getCategory());
assertEquals("configuration",pigService.getConfigDir());
assertEquals("2.0",pigService.getSchemaVersion());
Map osInfoMap=pigService.getOsSpecifics();
assertEquals(1,osInfoMap.size());
ServiceOsSpecific osSpecific=osInfoMap.get("centos6");
assertNotNull(osSpecific);
assertEquals("centos6",osSpecific.getOsFamily());
assertNull(osSpecific.getRepo());
List packages=osSpecific.getPackages();
assertEquals(2,packages.size());
ServiceOsSpecific.Package pkg=packages.get(0);
assertEquals("pig",pkg.getName());
assertFalse(pkg.getSkipUpgrade());
ServiceOsSpecific.Package lzoPackage=packages.get(1);
assertEquals("lzo",lzoPackage.getName());
assertTrue(lzoPackage.getSkipUpgrade());
assertEquals(pigService.getParent(),"common-services/PIG/1.0");
}
InternalCallVerifier EqualityVerifier stacks=stackManager.getStacks();
assertEquals(2,stacks.size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier stacks=stackManager.getStacks("HDP");
assertEquals(2,stacks.size());
}
Class: org.apache.ambari.server.stack.StackManagerMiscTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier stacks=stackManager.getStacks();
assertEquals(1,stacks.size());
assertNotNull(stacks.iterator().next().getService("HDFS"));
verify(metaInfoDao,stackDao,actionMetadata,osFamily);
}
Class: org.apache.ambari.server.stack.StackManagerTest InternalCallVerifier EqualityVerifier stacks=stackManager.getStacks();
assertEquals(19,stacks.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier components=zkService.getComponents();
assertTrue(components.size() == 2);
ComponentInfo componentInfo=components.get(1);
List clientConfigs=componentInfo.getClientConfigFiles();
assertEquals(2,clientConfigs.size());
assertEquals("zookeeper-env",clientConfigs.get(0).getDictionaryName());
assertEquals("zookeeper-env.sh",clientConfigs.get(0).getFileName());
assertEquals("env",clientConfigs.get(0).getType());
assertEquals("zookeeper-log4j",clientConfigs.get(1).getDictionaryName());
assertEquals("log4j.properties",clientConfigs.get(1).getFileName());
assertEquals("env",clientConfigs.get(1).getType());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier services=stack.getServices();
assertEquals(3,services.size());
assertEquals(6,stack.getService("HDFS").getComponents().size());
ServiceInfo sqoopService=stack.getService("SQOOP2");
assertNotNull(sqoopService);
assertEquals("Extended SQOOP",sqoopService.getComment());
assertEquals("Extended Version",sqoopService.getVersion());
assertNull(sqoopService.getServicePackageFolder());
Collection components=sqoopService.getComponents();
assertEquals(1,components.size());
ComponentInfo component=components.iterator().next();
assertEquals("SQOOP",component.getName());
StackInfo baseStack=stackManager.getStack("HDP","2.1.1");
ServiceInfo baseSqoopService=baseStack.getService("SQOOP");
assertEquals(baseSqoopService.isDeleted(),sqoopService.isDeleted());
assertEquals(baseSqoopService.getAlertsFile(),sqoopService.getAlertsFile());
assertEquals(baseSqoopService.getClientComponent(),sqoopService.getClientComponent());
assertEquals(baseSqoopService.getCommandScript(),sqoopService.getCommandScript());
assertEquals(baseSqoopService.getConfigDependencies(),sqoopService.getConfigDependencies());
assertEquals(baseSqoopService.getConfigDir(),sqoopService.getConfigDir());
assertEquals(baseSqoopService.getConfigDependenciesWithComponents(),sqoopService.getConfigDependenciesWithComponents());
assertEquals(baseSqoopService.getConfigTypeAttributes(),sqoopService.getConfigTypeAttributes());
assertEquals(baseSqoopService.getCustomCommands(),sqoopService.getCustomCommands());
assertEquals(baseSqoopService.getExcludedConfigTypes(),sqoopService.getExcludedConfigTypes());
assertEquals(baseSqoopService.getProperties(),sqoopService.getProperties());
assertEquals(baseSqoopService.getMetrics(),sqoopService.getMetrics());
assertNull(baseSqoopService.getMetricsFile());
assertNull(sqoopService.getMetricsFile());
assertEquals(baseSqoopService.getOsSpecifics(),sqoopService.getOsSpecifics());
assertEquals(baseSqoopService.getRequiredServices(),sqoopService.getRequiredServices());
assertEquals(baseSqoopService.getSchemaVersion(),sqoopService.getSchemaVersion());
ServiceInfo stormService=stack.getService("STORM");
assertNotNull(stormService);
assertEquals("STORM",stormService.getName());
ServiceInfo baseStormService=baseStack.getService("STORM");
assertEquals("Apache Hadoop Stream processing framework (Extended)",stormService.getComment());
assertEquals("New version",stormService.getVersion());
String packageDir=StringUtils.join(new String[]{"stacks","OTHER","1.0","services","STORM","package"},File.separator);
assertEquals(packageDir,stormService.getServicePackageFolder());
List stormServiceComponents=stormService.getComponents();
List baseStormServiceComponents=baseStormService.getComponents();
assertEquals(new HashSet(stormServiceComponents),new HashSet(baseStormServiceComponents));
assertEquals(baseStormService.isDeleted(),stormService.isDeleted());
assertEquals(baseStormService.getAlertsFile(),stormService.getAlertsFile());
assertEquals(baseStormService.getClientComponent(),stormService.getClientComponent());
assertEquals(baseStormService.getCommandScript(),stormService.getCommandScript());
assertEquals(baseStormService.getConfigDependencies(),stormService.getConfigDependencies());
assertEquals(baseStormService.getConfigDir(),stormService.getConfigDir());
assertEquals(baseStormService.getConfigDependenciesWithComponents(),stormService.getConfigDependenciesWithComponents());
assertEquals(baseStormService.getConfigTypeAttributes(),stormService.getConfigTypeAttributes());
assertEquals(baseStormService.getCustomCommands(),stormService.getCustomCommands());
assertEquals(baseStormService.getExcludedConfigTypes(),stormService.getExcludedConfigTypes());
assertEquals(baseStormService.getProperties(),stormService.getProperties());
assertEquals(baseStormService.getMetrics(),stormService.getMetrics());
assertNotNull(baseStormService.getMetricsFile());
assertNotNull(stormService.getMetricsFile());
assertFalse(baseStormService.getMetricsFile().equals(stormService.getMetricsFile()));
assertEquals(baseStormService.getOsSpecifics(),stormService.getOsSpecifics());
assertEquals(baseStormService.getRequiredServices(),stormService.getRequiredServices());
assertEquals(baseStormService.getSchemaVersion(),stormService.getSchemaVersion());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier roleCommandOrder=stack.getRoleCommandOrder().getContent();
assertTrue(roleCommandOrder.containsKey("optional_glusterfs"));
assertTrue(roleCommandOrder.containsKey("general_deps"));
assertTrue(roleCommandOrder.containsKey("optional_no_glusterfs"));
assertTrue(roleCommandOrder.containsKey("namenode_optional_ha"));
assertTrue(roleCommandOrder.containsKey("resourcemanager_optional_ha"));
Map generalDeps=(Map)roleCommandOrder.get("general_deps");
assertTrue(generalDeps.containsKey("HBASE_MASTER-START"));
assertTrue(generalDeps.containsKey("HBASE_REGIONSERVER-START"));
Map optionalNoGlusterfs=(Map)roleCommandOrder.get("optional_no_glusterfs");
assertTrue(optionalNoGlusterfs.containsKey("SECONDARY_NAMENODE-START"));
ArrayList hbaseMasterStartValues=(ArrayList)generalDeps.get("HBASE_MASTER-START");
assertTrue(hbaseMasterStartValues.get(0).equals("ZOOKEEPER_SERVER-START"));
assertTrue(optionalNoGlusterfs.containsKey("NAMENODE-STOP"));
ArrayList nameNodeStopValues=(ArrayList)optionalNoGlusterfs.get("NAMENODE-STOP");
assertTrue(nameNodeStopValues.contains("JOBTRACKER-STOP"));
assertTrue(nameNodeStopValues.contains("CUSTOM_MASTER-STOP"));
assertTrue(generalDeps.containsKey("CUSTOM_MASTER-START"));
ArrayList customMasterStartValues=(ArrayList)generalDeps.get("CUSTOM_MASTER-START");
assertTrue(customMasterStartValues.contains("ZOOKEEPER_SERVER-START"));
assertTrue(customMasterStartValues.contains("NAMENODE-START"));
}
InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier rco=hdp.getRoleCommandOrder().getContent();
Map generalDeps=(Map)rco.get("general_deps");
Map optionalNoGlusterfs=(Map)rco.get("optional_no_glusterfs");
String nameNodeRoleCommand=Role.NAMENODE + "-" + RoleCommand.START;
ArrayList nameNodeBlockers=(ArrayList)optionalNoGlusterfs.get(nameNodeRoleCommand);
assertTrue(nameNodeRoleCommand + " should be dependent of " + rangerUserSyncRoleCommand,nameNodeBlockers.contains(rangerUserSyncRoleCommand));
String dataNodeRoleCommand=Role.DATANODE + "-" + RoleCommand.START;
ArrayList dataNodeBlockers=(ArrayList)optionalNoGlusterfs.get(dataNodeRoleCommand);
assertTrue(dataNodeRoleCommand + " should be dependent of " + rangerUserSyncRoleCommand,dataNodeBlockers.contains(rangerUserSyncRoleCommand));
String resourceManagerCommandRoleCommand=Role.RESOURCEMANAGER + "-" + RoleCommand.START;
ArrayList resourceManagerBlockers=(ArrayList)generalDeps.get(resourceManagerCommandRoleCommand);
assertTrue(resourceManagerCommandRoleCommand + " should be dependent of " + rangerUserSyncRoleCommand,resourceManagerBlockers.contains(rangerUserSyncRoleCommand));
String hbaseRoleCommand=Role.HBASE_MASTER + "-" + RoleCommand.START;
ArrayList hbaseBlockers=(ArrayList)generalDeps.get(hbaseRoleCommand);
assertTrue(hbaseRoleCommand + " should be dependent of " + rangerUserSyncRoleCommand,hbaseBlockers.contains(rangerUserSyncRoleCommand));
assertTrue(hbaseRoleCommand + " should be dependent of " + zookeeperServerRoleCommand,hbaseBlockers.contains(zookeeperServerRoleCommand));
String knoxRoleCommand=Role.KNOX_GATEWAY + "-" + RoleCommand.START;
ArrayList knoxBlockers=(ArrayList)generalDeps.get(knoxRoleCommand);
assertTrue(knoxRoleCommand + " should be dependent of " + rangerUserSyncRoleCommand,knoxBlockers.contains(rangerUserSyncRoleCommand));
String kafkaRoleCommand=Role.KAFKA_BROKER + "-" + RoleCommand.START;
ArrayList kafkaBlockers=(ArrayList)generalDeps.get(kafkaRoleCommand);
assertTrue(Role.KAFKA_BROKER + "-" + RoleCommand.START+ " should be dependent of "+ rangerUserSyncRoleCommand,kafkaBlockers.contains(rangerUserSyncRoleCommand));
String hiveRoleCommand=Role.HIVE_SERVER + "-" + RoleCommand.START;
ArrayList hiveBlockers=(ArrayList)generalDeps.get(hiveRoleCommand);
assertTrue(hiveRoleCommand + " should be dependent of " + rangerUserSyncRoleCommand,hiveBlockers.contains(rangerUserSyncRoleCommand));
assertTrue(hiveRoleCommand + " should be dependent of " + nodeManagerRoleCommand,hiveBlockers.contains(nodeManagerRoleCommand));
assertTrue(hiveRoleCommand + " should be dependent of " + mySqlServerRoleCommand,hiveBlockers.contains(mySqlServerRoleCommand));
String stormRoleCommand=Role.NIMBUS + "-" + RoleCommand.START;
ArrayList stormBlockers=(ArrayList)generalDeps.get(stormRoleCommand);
assertTrue(stormRoleCommand + " should be dependent of " + rangerUserSyncRoleCommand,stormBlockers.contains(rangerUserSyncRoleCommand));
assertTrue(stormRoleCommand + " should be dependent of " + zookeeperServerRoleCommand,stormBlockers.contains(zookeeperServerRoleCommand));
String kmsRoleCommand=Role.RANGER_KMS_SERVER + "-" + RoleCommand.START;
ArrayList rangerKmsBlockers=(ArrayList)generalDeps.get(kmsRoleCommand);
assertTrue(kmsRoleCommand + " should be dependent of " + rangerAdminRoleCommand,rangerKmsBlockers.contains(rangerAdminRoleCommand));
ArrayList rangerUserSyncBlockers=(ArrayList)generalDeps.get(rangerUserSyncRoleCommand);
assertTrue(rangerUserSyncRoleCommand + " should be dependent of " + rangerAdminRoleCommand,rangerUserSyncBlockers.contains(rangerAdminRoleCommand));
assertTrue(rangerUserSyncRoleCommand + " should be dependent of " + kmsRoleCommand,rangerUserSyncBlockers.contains(kmsRoleCommand));
ArrayList zookeeperBlockers=(ArrayList)generalDeps.get(zookeeperServerRoleCommand);
assertTrue(zookeeperServerRoleCommand + " should be dependent of " + rangerUserSyncRoleCommand,zookeeperBlockers.contains(rangerUserSyncRoleCommand));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier >> configTypes=hdfsService.getConfigTypeAttributes();
assertEquals(4,configTypes.size());
Map> configType=configTypes.get("global");
assertEquals(1,configType.size());
Map supportsMap=configType.get("supports");
assertEquals(3,supportsMap.size());
assertEquals("true",supportsMap.get("final"));
assertEquals("false",supportsMap.get("adding_forbidden"));
assertEquals("false",supportsMap.get("do_not_extend"));
configType=configTypes.get("hdfs-site");
assertEquals(1,configType.size());
supportsMap=configType.get("supports");
assertEquals(3,supportsMap.size());
assertEquals("false",supportsMap.get("final"));
assertEquals("false",supportsMap.get("adding_forbidden"));
assertEquals("false",supportsMap.get("do_not_extend"));
configType=configTypes.get("core-site");
assertEquals(1,configType.size());
supportsMap=configType.get("supports");
assertEquals(3,supportsMap.size());
assertEquals("false",supportsMap.get("final"));
assertEquals("false",supportsMap.get("adding_forbidden"));
assertEquals("false",supportsMap.get("do_not_extend"));
configType=configTypes.get("hadoop-policy");
assertEquals(1,configType.size());
supportsMap=configType.get("supports");
assertEquals(3,supportsMap.size());
assertEquals("false",supportsMap.get("final"));
assertEquals("false",supportsMap.get("adding_forbidden"));
assertEquals("false",supportsMap.get("do_not_extend"));
ServiceInfo yarnService=stack.getService("YARN");
configTypes=yarnService.getConfigTypeAttributes();
assertEquals(4,configTypes.size());
assertTrue(configTypes.containsKey("yarn-site"));
assertTrue(configTypes.containsKey("core-site"));
assertTrue(configTypes.containsKey("global"));
assertTrue(configTypes.containsKey("capacity-scheduler"));
configType=configTypes.get("yarn-site");
supportsMap=configType.get("supports");
assertEquals(3,supportsMap.size());
assertEquals("false",supportsMap.get("final"));
assertEquals("true",supportsMap.get("adding_forbidden"));
assertEquals("true",supportsMap.get("do_not_extend"));
ServiceInfo mrService=stack.getService("MAPREDUCE2");
configTypes=mrService.getConfigTypeAttributes();
assertEquals(3,configTypes.size());
assertTrue(configTypes.containsKey("mapred-site"));
assertTrue(configTypes.containsKey("core-site"));
assertTrue(configTypes.containsKey("mapred-queue-acls"));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier stacks=stackManager.getStacks("HDP");
assertEquals(15,stacks.size());
stacks=stackManager.getStacks("OTHER");
assertEquals(2,stacks.size());
}
BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier allServices=stack.getServices();
assertEquals(13,allServices.size());
boolean monitoringServiceFound=false;
for ( ServiceInfo serviceInfo : allServices) {
if (serviceInfo.getName().equals("FAKENAGIOS")) {
monitoringServiceFound=true;
assertTrue(serviceInfo.isMonitoringService());
}
else {
assertNull(serviceInfo.isMonitoringService());
}
}
assertTrue(monitoringServiceFound);
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier services=stack.getServices();
assertEquals(3,services.size());
Map serviceMap=new HashMap();
for ( ServiceInfo service : services) {
serviceMap.put(service.getName(),service);
}
ServiceInfo hdfsService=serviceMap.get("HDFS");
assertNotNull(hdfsService);
List components=hdfsService.getComponents();
assertEquals(6,components.size());
List properties=hdfsService.getProperties();
assertEquals(62,properties.size());
boolean hdfsPropFound=false;
boolean hbasePropFound=false;
for ( PropertyInfo p : properties) {
if (p.getName().equals("hbase.regionserver.msginterval")) {
assertEquals("hbase-site.xml",p.getFilename());
hbasePropFound=true;
}
else if (p.getName().equals("dfs.name.dir")) {
assertEquals("hdfs-site.xml",p.getFilename());
hdfsPropFound=true;
}
}
assertTrue(hbasePropFound);
assertTrue(hdfsPropFound);
ServiceInfo mrService=serviceMap.get("MAPREDUCE");
assertNotNull(mrService);
components=mrService.getComponents();
assertEquals(3,components.size());
ServiceInfo pigService=serviceMap.get("PIG");
assertNotNull(pigService);
assertEquals("PIG",pigService.getName());
assertEquals("1.0",pigService.getVersion());
assertEquals("This is comment for PIG service",pigService.getComment());
components=pigService.getComponents();
assertEquals(1,components.size());
CommandScriptDefinition commandScript=pigService.getCommandScript();
assertEquals("scripts/service_check.py",commandScript.getScript());
assertEquals(CommandScriptDefinition.Type.PYTHON,commandScript.getScriptType());
assertEquals(300,commandScript.getTimeout());
List configDependencies=pigService.getConfigDependencies();
assertEquals(1,configDependencies.size());
assertEquals("global",configDependencies.get(0));
assertEquals("global",pigService.getConfigDependenciesWithComponents().get(0));
ComponentInfo client=pigService.getClientComponent();
assertNotNull(client);
assertEquals("PIG",client.getName());
assertEquals("0+",client.getCardinality());
assertEquals("CLIENT",client.getCategory());
assertEquals("configuration",pigService.getConfigDir());
assertEquals("2.0",pigService.getSchemaVersion());
Map osInfoMap=pigService.getOsSpecifics();
assertEquals(1,osInfoMap.size());
ServiceOsSpecific osSpecific=osInfoMap.get("centos6");
assertNotNull(osSpecific);
assertEquals("centos6",osSpecific.getOsFamily());
assertNull(osSpecific.getRepo());
List packages=osSpecific.getPackages();
assertEquals(1,packages.size());
ServiceOsSpecific.Package pkg=packages.get(0);
assertEquals("pig",pkg.getName());
assertNull(pigService.getParent());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier serviceComponents=service.getComponents();
List baseStormServiceCompoents=baseSqoopService.getComponents();
assertEquals(serviceComponents,baseStormServiceCompoents);
assertEquals(baseSqoopService.isDeleted(),service.isDeleted());
assertEquals(baseSqoopService.getAlertsFile(),service.getAlertsFile());
assertEquals(baseSqoopService.getClientComponent(),service.getClientComponent());
assertEquals(baseSqoopService.getCommandScript(),service.getCommandScript());
assertEquals(baseSqoopService.getConfigDependencies(),service.getConfigDependencies());
assertEquals(baseSqoopService.getConfigDir(),service.getConfigDir());
assertEquals(baseSqoopService.getConfigDependenciesWithComponents(),service.getConfigDependenciesWithComponents());
assertEquals(baseSqoopService.getConfigTypeAttributes(),service.getConfigTypeAttributes());
assertEquals(baseSqoopService.getCustomCommands(),service.getCustomCommands());
assertEquals(baseSqoopService.getExcludedConfigTypes(),service.getExcludedConfigTypes());
assertEquals(baseSqoopService.getProperties(),service.getProperties());
assertEquals(baseSqoopService.getMetrics(),service.getMetrics());
assertNull(baseSqoopService.getMetricsFile());
assertNull(service.getMetricsFile());
assertEquals(baseSqoopService.getOsSpecifics(),service.getOsSpecifics());
assertEquals(baseSqoopService.getRequiredServices(),service.getRequiredServices());
assertEquals(baseSqoopService.getSchemaVersion(),service.getSchemaVersion());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier services=stack.getServices();
assertEquals(16,services.size());
HashSet expectedServices=new HashSet();
expectedServices.add("GANGLIA");
expectedServices.add("HBASE");
expectedServices.add("HCATALOG");
expectedServices.add("HDFS");
expectedServices.add("HIVE");
expectedServices.add("MAPREDUCE2");
expectedServices.add("OOZIE");
expectedServices.add("PIG");
expectedServices.add("SQOOP");
expectedServices.add("YARN");
expectedServices.add("ZOOKEEPER");
expectedServices.add("STORM");
expectedServices.add("FLUME");
expectedServices.add("FAKENAGIOS");
expectedServices.add("TEZ");
expectedServices.add("AMBARI_METRICS");
ServiceInfo pigService=null;
for ( ServiceInfo service : services) {
if (service.getName().equals("PIG")) {
pigService=service;
}
assertTrue(expectedServices.remove(service.getName()));
}
assertTrue(expectedServices.isEmpty());
assertNotNull(pigService);
assertEquals("0.12.1.2.1.1",pigService.getVersion());
assertEquals("Scripting platform for analyzing large datasets (Extended)",pigService.getComment());
ServiceInfo basePigService=stackManager.getStack("HDP","2.0.5").getService("PIG");
assertEquals("0.11.1.2.0.5.0",basePigService.getVersion());
assertEquals(1,basePigService.getComponents().size());
assertEquals(2,pigService.getComponents().size());
assertEquals(0,basePigService.getProperties().size());
assertEquals(1,pigService.getProperties().size());
assertEquals("content",pigService.getProperties().get(0).getName());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier allServices=stack.getServices();
assertEquals(11,allServices.size());
HashSet expectedServices=new HashSet();
expectedServices.add("GANGLIA");
expectedServices.add("HBASE");
expectedServices.add("HCATALOG");
expectedServices.add("HDFS");
expectedServices.add("HIVE");
expectedServices.add("MAPREDUCE2");
expectedServices.add("OOZIE");
expectedServices.add("PIG");
expectedServices.add("ZOOKEEPER");
expectedServices.add("FLUME");
expectedServices.add("YARN");
for ( ServiceInfo service : allServices) {
assertTrue(expectedServices.remove(service.getName()));
}
assertTrue(expectedServices.isEmpty());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier >> configTypes=service.getConfigTypeAttributes();
assertEquals(2,configTypes.size());
assertTrue(configTypes.containsKey("hbase-site"));
assertTrue(configTypes.containsKey("hbase-policy"));
stack=stackManager.getStack("HDP","2.1.1");
service=stack.getService("HBASE");
assertFalse(service.hasConfigType("global"));
configTypes=service.getConfigTypeAttributes();
assertEquals(2,configTypes.size());
assertTrue(configTypes.containsKey("hbase-site"));
assertTrue(configTypes.containsKey("hbase-policy"));
assertFalse(configTypes.containsKey("global"));
stack=stackManager.getStack("OTHER","2.0");
service=stack.getService("HBASE");
assertFalse(service.hasConfigType("hbase-policy"));
assertFalse(service.hasConfigType("global"));
configTypes=service.getConfigTypeAttributes();
assertEquals(1,configTypes.size());
assertTrue(configTypes.containsKey("hbase-site"));
}
Class: org.apache.ambari.server.stack.ThemeModuleTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.stageplanner.TestStagePlanner APIUtilityVerifier InternalCallVerifier EqualityVerifier outStages=rg.getStages();
for ( Stage s : outStages) {
System.out.println(s.toString());
}
assertEquals(1,outStages.size());
assertEquals(stage.getExecutionCommands(hostname),outStages.get(0).getExecutionCommands(hostname));
}
InternalCallVerifier EqualityVerifier outStages=rg.getStages();
for ( Stage s : outStages) {
System.out.println(s.toString());
}
assertEquals(4,outStages.size());
}
InternalCallVerifier EqualityVerifier outStages=rg.getStages();
for ( Stage s : outStages) {
System.out.println(s.toString());
}
assertEquals(3,outStages.size());
}
InternalCallVerifier EqualityVerifier outStages=rg.getStages();
for ( Stage s : outStages) {
System.out.println(s.toString());
}
assertEquals(2,outStages.size());
}
Class: org.apache.ambari.server.state.CheckHelperTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (){
@Override public Cluster answer( InvocationOnMock invocation) throws Throwable {
final String clusterName=invocation.getArguments()[0].toString();
if (clusterName.equals("existing")) {
return Mockito.mock(Cluster.class);
}
else {
throw new ClusterNotFoundException(clusterName);
}
}
}
);
final OsFamily osFamily=Mockito.mock(OsFamily.class);
final Injector injector=Guice.createInjector(new AbstractModule(){
@Override protected void configure(){
bind(Clusters.class).toInstance(clusters);
bind(ClusterVersionDAO.class).toProvider(Providers.of(null));
bind(HostVersionDAO.class).toProvider(Providers.of(null));
bind(UpgradeDAO.class).toProvider(Providers.of(null));
bind(RepositoryVersionDAO.class).toProvider(Providers.of(null));
bind(RepositoryVersionHelper.class).toProvider(Providers.of(null));
bind(AmbariMetaInfo.class).toProvider(Providers.of(null));
bind(ServicesUpCheck.class).toInstance(new ServicesUpCheck());
bind(OsFamily.class).toInstance(osFamily);
}
}
);
final CheckHelper helper=injector.getInstance(CheckHelper.class);
List updateChecksRegistry=new ArrayList();
updateChecksRegistry.add(injector.getInstance(ServicesUpCheck.class));
List upgradeChecks=helper.performChecks(new PrereqCheckRequest("existing"),updateChecksRegistry);
Assert.assertEquals(PrereqCheckStatus.PASS,upgradeChecks.get(0).getStatus());
upgradeChecks=helper.performChecks(new PrereqCheckRequest("non-existing"),updateChecksRegistry);
Assert.assertEquals(PrereqCheckStatus.FAIL,upgradeChecks.get(0).getStatus());
Assert.assertTrue(!upgradeChecks.get(0).getFailReason().equals("Unexpected server error happened"));
}
InternalCallVerifier EqualityVerifier updateChecksRegistry=new ArrayList();
AbstractCheckDescriptor descriptor=EasyMock.createNiceMock(AbstractCheckDescriptor.class);
descriptor.perform(EasyMock.anyObject(),EasyMock.anyObject());
EasyMock.expectLastCall().andThrow(new AmbariException("error"));
EasyMock.expect(descriptor.isApplicable(EasyMock.anyObject())).andReturn(true);
EasyMock.expect(descriptor.getDescription()).andReturn(CheckDescription.HOSTS_HEARTBEAT).anyTimes();
EasyMock.replay(descriptor);
updateChecksRegistry.add(descriptor);
final List upgradeChecks=helper.performChecks(new PrereqCheckRequest("cluster"),updateChecksRegistry);
EasyMock.verify(descriptor);
Assert.assertEquals(PrereqCheckStatus.FAIL,upgradeChecks.get(0).getStatus());
}
Class: org.apache.ambari.server.state.ConfigGroupTest InternalCallVerifier NullVerifier TestInitializer InternalCallVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier properties=new HashMap();
properties.put("key1","value1");
Map> propertiesAttributes=new HashMap>();
Map attributes=new HashMap();
attributes.put("key1","true");
propertiesAttributes.put("final",attributes);
Config config=new ConfigImpl("test-site");
config.setProperties(properties);
config.setPropertiesAttributes(propertiesAttributes);
config.setTag("version100");
configGroup.addConfiguration(config);
Assert.assertEquals(2,configGroup.getConfigurations().values().size());
configGroup.setName("NewName");
configGroup.setDescription("NewDesc");
configGroup.setTag("NewTag");
configGroup.persist();
configGroup.refresh();
configGroupEntity=configGroupDAO.findByName("NewName");
Assert.assertNotNull(configGroupEntity);
Assert.assertEquals(2,configGroupEntity.getConfigGroupHostMappingEntities().size());
Assert.assertEquals(2,configGroupEntity.getConfigGroupConfigMappingEntities().size());
Assert.assertEquals("NewTag",configGroupEntity.getTag());
Assert.assertEquals("NewDesc",configGroupEntity.getDescription());
Assert.assertNotNull(cluster.getConfig("test-site","version100"));
ConfigGroupConfigMappingEntity configMappingEntity=null;
Object[] array=configGroupEntity.getConfigGroupConfigMappingEntities().toArray();
for ( Object o : array) {
if ("test-site".equals(((ConfigGroupConfigMappingEntity)o).getConfigType())) {
configMappingEntity=(ConfigGroupConfigMappingEntity)o;
break;
}
}
Assert.assertNotNull(configMappingEntity);
Assert.assertTrue(configMappingEntity.getClusterConfigEntity().getData().contains("{\"key1\":\"value1\"}"));
Assert.assertEquals("{\"final\":{\"key1\":\"true\"}}",configMappingEntity.getClusterConfigEntity().getAttributes());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier configMappingEntities=configGroupEntity.getConfigGroupConfigMappingEntities();
Collection hostMappingEntities=configGroupEntity.getConfigGroupHostMappingEntities();
Assert.assertEquals(configGroup.getId(),configGroupEntity.getGroupId());
Assert.assertEquals(configGroup.getTag(),configGroupEntity.getTag());
Assert.assertNotNull(configMappingEntities);
Assert.assertNotNull(hostMappingEntities);
Assert.assertEquals("h1",hostMappingEntities.iterator().next().getHostname());
ConfigGroupConfigMappingEntity configMappingEntity=configMappingEntities.iterator().next();
Assert.assertEquals("hdfs-site",configMappingEntity.getConfigType());
Assert.assertEquals("testversion",configMappingEntity.getVersionTag());
}
Class: org.apache.ambari.server.state.ConfigHelperTest.RunWithCustomModule APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier serviceProperties=Arrays.asList(mockPropertyInfo1,mockPropertyInfo2);
expect(mockStackVersion.getStackName()).andReturn("HDP").once();
expect(mockStackVersion.getStackVersion()).andReturn("2.2").once();
expect(mockAmbariMetaInfo.getService("HDP","2.2","SERVICE")).andReturn(mockServiceInfo).once();
expect(mockServiceInfo.getProperties()).andReturn(serviceProperties).once();
replay(mockAmbariMetaInfo,mockStackVersion,mockServiceInfo,mockPropertyInfo1,mockPropertyInfo2);
mockAmbariMetaInfo.init();
Set result=injector.getInstance(ConfigHelper.class).getServiceProperties(mockStackVersion,"SERVICE",false);
Assert.assertNotNull(result);
Assert.assertEquals(2,result.size());
verify(mockAmbariMetaInfo,mockStackVersion,mockServiceInfo,mockPropertyInfo1,mockPropertyInfo2);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier serviceProperties=Arrays.asList(mockPropertyInfo1,mockPropertyInfo2);
expect(mockStackVersion.getStackName()).andReturn("HDP").once();
expect(mockStackVersion.getStackVersion()).andReturn("2.2").once();
expect(mockAmbariMetaInfo.getService("HDP","2.2","SERVICE")).andReturn(mockServiceInfo).once();
expect(mockServiceInfo.getProperties()).andReturn(serviceProperties).once();
expect(mockServiceInfo.getExcludedConfigTypes()).andReturn(Collections.singleton("excluded-type")).once();
expect(mockPropertyInfo1.getFilename()).andReturn("included-type.xml").times(2);
expect(mockPropertyInfo2.getFilename()).andReturn("excluded-type.xml").once();
replay(mockAmbariMetaInfo,mockStackVersion,mockServiceInfo,mockPropertyInfo1,mockPropertyInfo2);
mockAmbariMetaInfo.init();
Set result=injector.getInstance(ConfigHelper.class).getServiceProperties(mockStackVersion,"SERVICE",true);
Assert.assertNotNull(result);
Assert.assertEquals(1,result.size());
Assert.assertEquals("included-type.xml",result.iterator().next().getFilename());
verify(mockAmbariMetaInfo,mockStackVersion,mockServiceInfo,mockPropertyInfo1,mockPropertyInfo2);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier serviceProperties=Arrays.asList(mockPropertyInfo1,mockPropertyInfo2);
expect(mockCluster.getCurrentStackVersion()).andReturn(mockStackVersion).once();
expect(mockStackVersion.getStackName()).andReturn("HDP").once();
expect(mockStackVersion.getStackVersion()).andReturn("2.2").once();
expect(mockAmbariMetaInfo.getService("HDP","2.2","SERVICE")).andReturn(mockServiceInfo).once();
expect(mockServiceInfo.getProperties()).andReturn(serviceProperties).once();
replay(mockAmbariMetaInfo,mockCluster,mockStackVersion,mockServiceInfo,mockPropertyInfo1,mockPropertyInfo2);
mockAmbariMetaInfo.init();
Set result=injector.getInstance(ConfigHelper.class).getServiceProperties(mockCluster,"SERVICE");
Assert.assertNotNull(result);
Assert.assertEquals(2,result.size());
verify(mockAmbariMetaInfo,mockCluster,mockStackVersion,mockServiceInfo,mockPropertyInfo1,mockPropertyInfo2);
}
Class: org.apache.ambari.server.state.ConfigHelperTest.RunWithInMemoryDefaultTestModule InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier properties=currentConfig.getProperties();
Assert.assertEquals("version1",currentConfig.getTag());
Assert.assertEquals("simple",properties.get("oozie.authentication.type"));
Assert.assertEquals("false",properties.get("oozie.service.HadoopAccessorService.kerberos.enabled"));
Map updates=new HashMap();
updates.put("oozie.authentication.type","kerberos");
updates.put("oozie.service.HadoopAccessorService.kerberos.enabled","true");
configHelper.updateConfigType(cluster,managementController,"oozie-site",updates,null,"admin","Test " + "note");
Config updatedConfig=cluster.getDesiredConfigByType("oozie-site");
Assert.assertFalse("version1".equals(updatedConfig.getTag()));
properties=updatedConfig.getProperties();
Assert.assertTrue(properties.containsKey("oozie.authentication.type"));
Assert.assertEquals("kerberos",properties.get("oozie.authentication.type"));
Assert.assertTrue(properties.containsKey("oozie.service.HadoopAccessorService.kerberos.enabled"));
Assert.assertEquals("true",properties.get("oozie.service.HadoopAccessorService.kerberos.enabled"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier properties=new HashMap();
properties.put("a","b");
properties.put("c","d");
config1.setProperties(properties);
final Config config2=new ConfigImpl("global");
config2.setTag("version122");
Map properties2=new HashMap();
properties2.put("namenode_heapsize","1111");
config2.setProperties(properties2);
Long groupId=addConfigGroup("g1","t1",new ArrayList(){
{
add("h1");
}
}
,new ArrayList(){
{
add(config1);
add(config2);
}
}
);
Assert.assertNotNull(groupId);
Map> propertyMap=configHelper.getEffectiveConfigProperties(cluster,configHelper.getEffectiveDesiredTags(cluster,"h1"));
Assert.assertNotNull(propertyMap);
Assert.assertTrue(propertyMap.containsKey("global"));
Map globalProps=propertyMap.get("global");
Assert.assertEquals("1111",globalProps.get("namenode_heapsize"));
Assert.assertEquals("/hadoop/hdfs/namenode",globalProps.get("dfs_namenode_name_dir"));
Assert.assertTrue(propertyMap.containsKey("core-site"));
Map coreProps=propertyMap.get("core-site");
Assert.assertTrue(coreProps.containsKey("a"));
Assert.assertTrue(coreProps.containsKey("c"));
Assert.assertEquals("30",coreProps.get("ipc.client.connect.max.retries"));
}
InternalCallVerifier BooleanVerifier schReturn=new HashMap();
HostConfig hc=new HostConfig();
hc.setDefaultVersionTag("version2");
schReturn.put("flume-conf",hc);
ServiceComponentHost sch=createNiceMock(ServiceComponentHost.class);
expect(sch.getActualConfigs()).andReturn(schReturn).times(6);
expect(sch.getHostName()).andReturn("h1").anyTimes();
expect(sch.getClusterId()).andReturn(1l).anyTimes();
expect(sch.getServiceName()).andReturn("FLUME").anyTimes();
expect(sch.getServiceComponentName()).andReturn("FLUME_HANDLER").anyTimes();
replay(sch);
Assert.assertTrue(configHelper.isStaleConfigs(sch));
HostConfig hc2=new HostConfig();
hc2.setDefaultVersionTag("version1");
schReturn.put("flume-conf",hc2);
configHelper.invalidateStaleConfigsCache();
Assert.assertFalse(configHelper.isStaleConfigs(sch));
List hosts=new ArrayList();
hosts.add("h1");
List configs=new ArrayList();
ConfigImpl configImpl=new ConfigImpl("flume-conf");
configImpl.setTag("FLUME1");
configs.add(configImpl);
addConfigGroup("configGroup1","FLUME",hosts,configs);
Assert.assertTrue(configHelper.isStaleConfigs(sch));
HostConfig hc3=new HostConfig();
hc3.setDefaultVersionTag("version1");
hc3.getConfigGroupOverrides().put(1l,"FLUME1");
schReturn.put("flume-conf",hc3);
configHelper.invalidateStaleConfigsCache();
Assert.assertFalse(configHelper.isStaleConfigs(sch));
HostConfig hc4=new HostConfig();
hc4.setDefaultVersionTag("version1");
hc4.getConfigGroupOverrides().put(1l,"FLUME2");
schReturn.put("flume-conf",hc4);
configHelper.invalidateStaleConfigsCache();
Assert.assertTrue(configHelper.isStaleConfigs(sch));
HostConfig hc5=new HostConfig();
hc5.setDefaultVersionTag("version3");
hc5.getConfigGroupOverrides().put(1l,"FLUME1");
schReturn.put("flume-conf",hc5);
configHelper.invalidateStaleConfigsCache();
Assert.assertTrue(configHelper.isStaleConfigs(sch));
verify(sch);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier attributes=new HashMap();
attributes.put("fs.trash.interval","11");
attributes.put("b","y");
Map> config1Attributes=new HashMap>();
config1Attributes.put("attribute1",attributes);
config1.setPropertiesAttributes(config1Attributes);
final Config config2=new ConfigImpl("global");
config2.setTag("version122");
attributes=new HashMap();
attributes.put("namenode_heapsize","z");
attributes.put("c","q");
Map> config2Attributes=new HashMap>();
config2Attributes.put("attribute2",attributes);
config2.setPropertiesAttributes(config2Attributes);
Long groupId=addConfigGroup("g1","t1",new ArrayList(){
{
add("h1");
}
}
,new ArrayList(){
{
add(config1);
add(config2);
}
}
);
Assert.assertNotNull(groupId);
Map>> effectiveAttributes=configHelper.getEffectiveConfigAttributes(cluster,configHelper.getEffectiveDesiredTags(cluster,"h1"));
Assert.assertNotNull(effectiveAttributes);
Assert.assertEquals(4,effectiveAttributes.size());
Assert.assertTrue(effectiveAttributes.containsKey("global"));
Map> globalAttrs=effectiveAttributes.get("global");
Assert.assertEquals(1,globalAttrs.size());
Assert.assertTrue(globalAttrs.containsKey("attribute2"));
Map attribute2Occurances=globalAttrs.get("attribute2");
Assert.assertEquals(3,attribute2Occurances.size());
Assert.assertTrue(attribute2Occurances.containsKey("namenode_heapsize"));
Assert.assertEquals("z",attribute2Occurances.get("namenode_heapsize"));
Assert.assertTrue(attribute2Occurances.containsKey("dfs_namenode_name_dir"));
Assert.assertEquals("3",attribute2Occurances.get("dfs_namenode_name_dir"));
Assert.assertTrue(attribute2Occurances.containsKey("c"));
Assert.assertEquals("q",attribute2Occurances.get("c"));
Assert.assertTrue(effectiveAttributes.containsKey("core-site"));
Map> coreAttrs=effectiveAttributes.get("core-site");
Assert.assertEquals(1,coreAttrs.size());
Assert.assertTrue(coreAttrs.containsKey("attribute1"));
Map attribute1Occurances=coreAttrs.get("attribute1");
Assert.assertEquals(3,attribute1Occurances.size());
Assert.assertTrue(attribute1Occurances.containsKey("ipc.client.connect.max.retries"));
Assert.assertEquals("1",attribute1Occurances.get("ipc.client.connect.max.retries"));
Assert.assertTrue(attribute1Occurances.containsKey("fs.trash.interval"));
Assert.assertEquals("11",attribute1Occurances.get("fs.trash.interval"));
Assert.assertTrue(attribute1Occurances.containsKey("b"));
Assert.assertEquals("y",attribute1Occurances.get("b"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier properties=new HashMap();
properties.put("a","b");
properties.put("c","d");
config.setProperties(properties);
Long groupId=addConfigGroup("g1","t1",new ArrayList(){
{
add("h1");
}
}
,new ArrayList(){
{
add(config);
}
}
);
Assert.assertNotNull(groupId);
Map> configTags=configHelper.getEffectiveDesiredTags(cluster,"h1");
Assert.assertNotNull(configTags);
Map tagsWithOverrides=configTags.get("core-site");
Assert.assertNotNull(tagsWithOverrides);
Assert.assertTrue(tagsWithOverrides.containsKey(ConfigHelper.CLUSTER_DEFAULT_TAG));
Assert.assertEquals("version1",tagsWithOverrides.get(ConfigHelper.CLUSTER_DEFAULT_TAG));
Assert.assertTrue(tagsWithOverrides.containsKey(groupId.toString()));
Assert.assertEquals("version122",tagsWithOverrides.get(groupId.toString()));
}
TestInitializer InternalCallVerifier NullVerifier HybridVerifier (){
{
put("ipc.client.connect.max.retries","30");
put("fs.trash.interval","30");
}
}
);
cr.setPropertiesAttributes(new HashMap>(){
{
Map attrs=new HashMap();
attrs.put("ipc.client.connect.max.retries","1");
attrs.put("fs.trash.interval","2");
put("attribute1",attrs);
}
}
);
final ClusterRequest clusterRequest1=new ClusterRequest(cluster.getClusterId(),clusterName,cluster.getDesiredStackVersion().getStackVersion(),null);
clusterRequest1.setDesiredConfig(Collections.singletonList(cr));
managementController.updateClusters(new HashSet(){
{
add(clusterRequest1);
}
}
,null);
ConfigurationRequest cr2=new ConfigurationRequest();
cr2.setClusterName(clusterName);
cr2.setType("flume-conf");
cr2.setVersionTag("version1");
final ClusterRequest clusterRequest2=new ClusterRequest(cluster.getClusterId(),clusterName,cluster.getDesiredStackVersion().getStackVersion(),null);
clusterRequest2.setDesiredConfig(Collections.singletonList(cr2));
managementController.updateClusters(new HashSet(){
{
add(clusterRequest2);
}
}
,null);
cr.setType("global");
cr.setVersionTag("version1");
cr.setProperties(new HashMap(){
{
put("dfs_namenode_name_dir","/hadoop/hdfs/namenode");
put("namenode_heapsize","1024");
}
}
);
cr.setPropertiesAttributes(new HashMap>(){
{
Map attrs=new HashMap();
attrs.put("dfs_namenode_name_dir","3");
attrs.put("namenode_heapsize","4");
put("attribute2",attrs);
}
}
);
final ClusterRequest clusterRequest3=new ClusterRequest(cluster.getClusterId(),clusterName,cluster.getDesiredStackVersion().getStackVersion(),null);
clusterRequest3.setDesiredConfig(Collections.singletonList(cr));
managementController.updateClusters(new HashSet(){
{
add(clusterRequest3);
}
}
,null);
ConfigurationRequest cr4=new ConfigurationRequest();
cr4.setClusterName(clusterName);
cr4.setType("oozie-site");
cr4.setVersionTag("version1");
cr4.setProperties(new HashMap(){
{
put("oozie.authentication.type","simple");
put("oozie.service.HadoopAccessorService.kerberos.enabled","false");
}
}
);
cr4.setPropertiesAttributes(null);
final ClusterRequest clusterRequest4=new ClusterRequest(cluster.getClusterId(),clusterName,cluster.getDesiredStackVersion().getStackVersion(),null);
clusterRequest4.setDesiredConfig(Collections.singletonList(cr4));
managementController.updateClusters(new HashSet(){
{
add(clusterRequest4);
}
}
,null);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > persistedAttributes=new HashMap>();
Map persistedFinalAttrs=new HashMap();
persistedFinalAttrs.put("a","true");
persistedFinalAttrs.put("c","true");
persistedFinalAttrs.put("d","true");
persistedAttributes.put("final",persistedFinalAttrs);
Map> confGroupAttributes=new HashMap>();
Map confGroupProperties=new HashMap();
confGroupProperties.put("a","any");
confGroupProperties.put("b","any");
confGroupProperties.put("c","any");
Config overrideConfig=new ConfigImpl(cluster,"type",confGroupProperties,confGroupAttributes,injector);
Map> result=configHelper.overrideAttributes(overrideConfig,persistedAttributes);
Assert.assertNotNull(result);
Assert.assertEquals(1,result.size());
Map finalResultAttributes=result.get("final");
Assert.assertNotNull(finalResultAttributes);
Assert.assertEquals(1,finalResultAttributes.size());
Assert.assertEquals("true",finalResultAttributes.get("d"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > persistedAttributes=new HashMap>();
Map persistedFinalAttrs=new HashMap();
persistedFinalAttrs.put("a","true");
persistedFinalAttrs.put("c","true");
persistedFinalAttrs.put("d","true");
persistedAttributes.put("final",persistedFinalAttrs);
Map confGroupProperties=new HashMap();
confGroupProperties.put("a","any");
confGroupProperties.put("b","any");
confGroupProperties.put("c","any");
Config overrideConfig=new ConfigImpl(cluster,"type",confGroupProperties,null,injector);
Map> result=configHelper.overrideAttributes(overrideConfig,persistedAttributes);
Assert.assertNotNull(result);
Assert.assertEquals(1,result.size());
Map finalResultAttributes=result.get("final");
Assert.assertNotNull(finalResultAttributes);
Assert.assertEquals(3,finalResultAttributes.size());
Assert.assertEquals("true",finalResultAttributes.get("a"));
Assert.assertEquals("true",finalResultAttributes.get("c"));
Assert.assertEquals("true",finalResultAttributes.get("d"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier properties=currentConfig.getProperties();
Map> propertiesAttributes=currentConfig.getPropertiesAttributes();
Assert.assertNotNull(propertiesAttributes);
Assert.assertEquals(1,propertiesAttributes.size());
Assert.assertTrue(propertiesAttributes.containsKey("attribute1"));
Assert.assertEquals("version1",currentConfig.getTag());
Assert.assertEquals("30",properties.get("fs.trash.interval"));
Assert.assertTrue(properties.containsKey("ipc.client.connect.max.retries"));
Assert.assertTrue(propertiesAttributes.get("attribute1").containsKey("ipc.client.connect.max.retries"));
Map updates=new HashMap();
updates.put("new-property","new-value");
updates.put("fs.trash.interval","updated-value");
Collection removals=Collections.singletonList("ipc.client.connect.max.retries");
configHelper.updateConfigType(cluster,managementController,"core-site",updates,removals,"admin","Test note");
Config updatedConfig=cluster.getDesiredConfigByType("core-site");
propertiesAttributes=updatedConfig.getPropertiesAttributes();
Assert.assertNotNull(propertiesAttributes);
Assert.assertEquals(1,propertiesAttributes.size());
Assert.assertTrue(propertiesAttributes.containsKey("attribute1"));
Assert.assertFalse("version1".equals(updatedConfig.getTag()));
properties=updatedConfig.getProperties();
Assert.assertTrue(properties.containsKey("new-property"));
Assert.assertEquals("new-value",properties.get("new-property"));
Assert.assertTrue(properties.containsKey("fs.trash.interval"));
Assert.assertEquals("updated-value",properties.get("fs.trash.interval"));
Assert.assertEquals("2",propertiesAttributes.get("attribute1").get("fs.trash.interval"));
Assert.assertFalse(properties.containsKey("ipc.client.connect.max.retries"));
Assert.assertFalse(propertiesAttributes.get("attribute1").containsKey("ipc.client.connect.max.retries"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > persistedAttributes=new HashMap>();
Map persistedFinalAttrs=new HashMap();
persistedFinalAttrs.put("a","true");
persistedFinalAttrs.put("c","true");
persistedFinalAttrs.put("d","true");
persistedAttributes.put("final",persistedFinalAttrs);
Map> confGroupAttributes=new HashMap>();
Map confGroupFinalAttrs=new HashMap();
confGroupFinalAttrs.put("b","true");
confGroupAttributes.put("final",confGroupFinalAttrs);
Map confGroupProperties=new HashMap();
confGroupProperties.put("a","any");
confGroupProperties.put("b","any");
confGroupProperties.put("c","any");
Config overrideConfig=new ConfigImpl(cluster,"type",confGroupProperties,confGroupAttributes,injector);
Map> result=configHelper.overrideAttributes(overrideConfig,persistedAttributes);
Assert.assertNotNull(result);
Assert.assertEquals(1,result.size());
Map finalResultAttributes=result.get("final");
Assert.assertNotNull(finalResultAttributes);
Assert.assertEquals(2,finalResultAttributes.size());
Assert.assertEquals("true",finalResultAttributes.get("b"));
Assert.assertEquals("true",finalResultAttributes.get("d"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > persistedAttributes=new HashMap>();
Map persistedFinalAttrs=new HashMap();
persistedFinalAttrs.put("a","true");
persistedFinalAttrs.put("c","true");
persistedFinalAttrs.put("d","true");
persistedAttributes.put("final",persistedFinalAttrs);
Map> confGroupAttributes=new HashMap>();
Map confGroupFinalAttrs=new HashMap();
confGroupFinalAttrs.put("b","true");
confGroupAttributes.put("final",confGroupFinalAttrs);
Config overrideConfig=new ConfigImpl(cluster,"type",null,confGroupAttributes,injector);
Map> result=configHelper.overrideAttributes(overrideConfig,persistedAttributes);
Assert.assertNotNull(result);
Assert.assertEquals(1,result.size());
Map finalResultAttributes=result.get("final");
Assert.assertNotNull(finalResultAttributes);
Assert.assertEquals(4,finalResultAttributes.size());
Assert.assertEquals("true",finalResultAttributes.get("a"));
Assert.assertEquals("true",finalResultAttributes.get("b"));
Assert.assertEquals("true",finalResultAttributes.get("c"));
Assert.assertEquals("true",finalResultAttributes.get("d"));
}
Class: org.apache.ambari.server.state.ConfigMergeHelperTest APIUtilityVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("HDFS",createNiceMock(Service.class));
put("ZK",createNiceMock(Service.class));
}
}
);
Set currentHDFSProperties=new HashSet(){
{
add(createPropertyInfo("hdfs-env.xml","equal.key","equal-value"));
}
}
;
Set currentZKProperties=new HashSet(){
{
add(createPropertyInfo("zk-env.xml","different.key","different-value-1"));
}
}
;
Set currentStackProperties=new HashSet(){
{
add(createPropertyInfo("hadoop-env.xml","equal.key","modified.value"));
}
}
;
expect(ambariMetaInfoMock.getServiceProperties(currentStackId.getStackName(),currentStackId.getStackVersion(),"HDFS")).andReturn(currentHDFSProperties);
expect(ambariMetaInfoMock.getServiceProperties(currentStackId.getStackName(),currentStackId.getStackVersion(),"ZK")).andReturn(currentZKProperties);
expect(ambariMetaInfoMock.getStackProperties(currentStackId.getStackName(),currentStackId.getStackVersion())).andReturn(currentStackProperties);
Set newHDFSProperties=new HashSet(){
{
add(createPropertyInfo("hdfs-env.xml","equal.key","equal-value"));
add(createPropertyInfo("new-hdfs-config.xml","equal.key","equal-value"));
}
}
;
Set newZKProperties=new HashSet(){
{
add(createPropertyInfo("zk-env.xml","equal.key","different-value-2"));
add(createPropertyInfo("zk-env.xml","new.key","new-value-2"));
}
}
;
Set newStackProperties=new HashSet(){
{
add(createPropertyInfo("hadoop-env.xml","equal.key","another.value"));
}
}
;
expect(ambariMetaInfoMock.getServiceProperties(newStackId.getStackName(),newStackId.getStackVersion(),"HDFS")).andReturn(newHDFSProperties);
expect(ambariMetaInfoMock.getServiceProperties(newStackId.getStackName(),newStackId.getStackVersion(),"ZK")).andReturn(newZKProperties);
expect(ambariMetaInfoMock.getStackProperties(newStackId.getStackName(),newStackId.getStackVersion())).andReturn(newStackProperties);
Map desiredHdfsEnvProperties=new HashMap(){
{
}
}
;
expect(clusterMock.getDesiredConfigByType("hdfs-env.xml")).andReturn(createConfigMock(desiredHdfsEnvProperties));
Map desiredZkEnvProperties=new HashMap(){
{
}
}
;
expect(clusterMock.getDesiredConfigByType("hdfs-env.xml")).andReturn(createConfigMock(desiredZkEnvProperties));
Map desiredHadoopEnvProperties=new HashMap(){
{
}
}
;
expect(clusterMock.getDesiredConfigByType("hadoop-env.xml")).andReturn(createConfigMock(desiredHadoopEnvProperties));
replay(clusterMock,clustersMock,ambariMetaInfoMock);
ConfigMergeHelper configMergeHelper=injector.getInstance(ConfigMergeHelper.class);
Map> conflicts=configMergeHelper.getConflicts("clustername",newStackId);
assertNotNull(conflicts);
assertEquals(2,conflicts.size());
for ( String key : conflicts.keySet()) {
if (key.equals("hdfs-env")) {
Map stringThreeWayValueMap=conflicts.get(key);
assertEquals(1,stringThreeWayValueMap.size());
assertEquals("equal-value",stringThreeWayValueMap.get("equal.key").oldStackValue);
assertEquals("equal-value",stringThreeWayValueMap.get("equal.key").newStackValue);
assertEquals("",stringThreeWayValueMap.get("equal.key").savedValue);
}
else if (key.equals("hadoop-env")) {
Map stringThreeWayValueMap=conflicts.get(key);
assertEquals(1,stringThreeWayValueMap.size());
assertEquals("modified.value",stringThreeWayValueMap.get("equal.key").oldStackValue);
assertEquals("another.value",stringThreeWayValueMap.get("equal.key").newStackValue);
assertEquals("",stringThreeWayValueMap.get("equal.key").savedValue);
}
else {
fail("Unexpected key");
}
}
assertEquals(2,conflicts.size());
}
Class: org.apache.ambari.server.state.DesiredConfigTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hosts=Arrays.asList(new DesiredConfig.HostOverride("h1","v2"),new DesiredConfig.HostOverride("h2","v3"));
dc.setHostOverrides(hosts);
Assert.assertNotNull("Expected host overrides to be set",dc.getHostOverrides());
Assert.assertEquals("Expected host override equality",hosts,dc.getHostOverrides());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.state.PropertyInfoTest InternalCallVerifier EqualityVerifier elements=new ArrayList();
Element e1=createNiceMock(Element.class);
Element e2=createNiceMock(Element.class);
Node n1=createNiceMock(Node.class);
Node n2=createNiceMock(Node.class);
elements.add(e1);
elements.add(e2);
expect(e1.getTagName()).andReturn("foo").anyTimes();
expect(e1.getFirstChild()).andReturn(n1).anyTimes();
expect(n1.getNodeValue()).andReturn("value1").anyTimes();
expect(e2.getTagName()).andReturn("bar").anyTimes();
expect(e2.getFirstChild()).andReturn(n2).anyTimes();
expect(n2.getNodeValue()).andReturn("value2").anyTimes();
replay(e1,e2,n1,n2);
Field f=property.getClass().getDeclaredField("propertyAttributes");
f.setAccessible(true);
f.set(property,elements);
Map attributes=property.getAttributesMap();
assertEquals(2,attributes.size());
assertEquals("value1",attributes.get("foo"));
assertEquals("value2",attributes.get("bar"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.state.RequestExecutionTest InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier batchRequestEntities=scheduleEntity.getRequestScheduleBatchRequestEntities();
Assert.assertNotNull(batchRequestEntities);
RequestScheduleBatchRequestEntity reqEntity1=null;
RequestScheduleBatchRequestEntity reqEntity2=null;
for ( RequestScheduleBatchRequestEntity reqEntity : batchRequestEntities) {
if (reqEntity.getRequestUri().equals("testUri1")) {
reqEntity1=reqEntity;
}
else if (reqEntity.getRequestUri().equals("testUri2")) {
reqEntity2=reqEntity;
}
}
Assert.assertNotNull(reqEntity1);
Assert.assertNotNull(reqEntity2);
Assert.assertEquals(Long.valueOf(10L),reqEntity1.getBatchId());
Assert.assertEquals(Long.valueOf(12L),reqEntity2.getBatchId());
Assert.assertEquals(BatchRequest.Type.DELETE.name(),reqEntity1.getRequestType());
Assert.assertEquals(BatchRequest.Type.POST.name(),reqEntity2.getRequestType());
Assert.assertEquals(requestExecution.getSchedule().getMinutes(),scheduleEntity.getMinutes());
Assert.assertEquals(requestExecution.getSchedule().getEndTime(),scheduleEntity.getEndTime());
}
TestInitializer InternalCallVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier batchRequests=new ArrayList();
BatchRequest batchRequest1=new BatchRequest();
batchRequest1.setOrderId(10L);
batchRequest1.setType(BatchRequest.Type.PUT);
batchRequest1.setUri("testUri3");
BatchRequest batchRequest2=new BatchRequest();
batchRequest2.setOrderId(12L);
batchRequest2.setType(BatchRequest.Type.POST);
batchRequest2.setUri("testUri4");
batchRequest2.setBody("testBody");
batchRequests.add(batchRequest1);
batchRequests.add(batchRequest2);
batches.getBatchRequests().addAll(batchRequests);
requestExecution.setBatch(batches);
requestExecution.getSchedule().setHours("11");
requestExecution.persist();
scheduleEntity=requestScheduleDAO.findById(id);
Assert.assertNotNull(scheduleEntity);
Collection batchRequestEntities=scheduleEntity.getRequestScheduleBatchRequestEntities();
Assert.assertNotNull(batchRequestEntities);
RequestScheduleBatchRequestEntity reqEntity1=null;
RequestScheduleBatchRequestEntity reqEntity2=null;
for ( RequestScheduleBatchRequestEntity reqEntity : batchRequestEntities) {
if (reqEntity.getRequestUri().equals("testUri3")) {
reqEntity1=reqEntity;
}
else if (reqEntity.getRequestUri().equals("testUri4")) {
reqEntity2=reqEntity;
}
}
Assert.assertNotNull(reqEntity1);
Assert.assertNotNull(reqEntity2);
Assert.assertEquals(Long.valueOf(10L),reqEntity1.getBatchId());
Assert.assertEquals(Long.valueOf(12L),reqEntity2.getBatchId());
Assert.assertEquals(BatchRequest.Type.PUT.name(),reqEntity1.getRequestType());
Assert.assertEquals(BatchRequest.Type.POST.name(),reqEntity2.getRequestType());
Assert.assertEquals("11",scheduleEntity.getHours());
}
InternalCallVerifier NullVerifier batchRequests=requestExecution.getBatch().getBatchRequests();
Assert.assertNotNull(batchRequests);
for ( BatchRequest batchRequest : batchRequests) {
if (batchRequest.getType().equals(BatchRequest.Type.POST.name())) {
postBatchRequest=batchRequest;
}
}
Assert.assertNotNull(postBatchRequest);
Assert.assertNull(postBatchRequest.getBody());
RequestScheduleResponse requestScheduleResponse=requestExecution.convertToResponseWithBody();
Assert.assertNotNull(requestScheduleResponse);
batchRequests=requestExecution.getBatch().getBatchRequests();
Assert.assertNotNull(batchRequests);
for ( BatchRequest batchRequest : batchRequests) {
if (batchRequest.getType().equals(BatchRequest.Type.POST.name())) {
postBatchRequest=batchRequest;
}
}
Assert.assertNotNull(postBatchRequest);
Assert.assertNotNull(postBatchRequest.getBody());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier batchRequestEntities=scheduleEntity.getRequestScheduleBatchRequestEntities();
Assert.assertNotNull(batchRequestEntities);
Assert.assertEquals(2,batchRequestEntities.size());
BatchRequestResponse batchRequestResponse=new BatchRequestResponse();
batchRequestResponse.setRequestId(1L);
batchRequestResponse.setReturnCode(200);
batchRequestResponse.setReturnMessage("test");
batchRequestResponse.setStatus("IN_PROGRESS");
requestExecution.updateBatchRequest(10L,batchRequestResponse,false);
scheduleEntity=requestScheduleDAO.findById(requestExecution.getId());
RequestScheduleBatchRequestEntity testEntity=null;
for ( RequestScheduleBatchRequestEntity entity : scheduleEntity.getRequestScheduleBatchRequestEntities()) {
if (entity.getBatchId().equals(10L)) {
testEntity=entity;
}
}
Assert.assertNotNull(testEntity);
Assert.assertEquals(200,testEntity.getReturnCode().intValue());
Assert.assertEquals("test",testEntity.getReturnMessage());
Assert.assertEquals("IN_PROGRESS",testEntity.getRequestStatus());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier batchRequestEntities=scheduleEntity.getRequestScheduleBatchRequestEntities();
Assert.assertNotNull(batchRequestEntities);
RequestScheduleBatchRequestEntity reqEntity1=null;
RequestScheduleBatchRequestEntity reqEntity2=null;
for ( RequestScheduleBatchRequestEntity reqEntity : batchRequestEntities) {
if (reqEntity.getRequestUri().equals("testUri1")) {
reqEntity1=reqEntity;
}
else if (reqEntity.getRequestUri().equals("testUri2")) {
reqEntity2=reqEntity;
}
}
Assert.assertNotNull(reqEntity1);
Assert.assertNotNull(reqEntity2);
Assert.assertEquals(Long.valueOf(10L),reqEntity1.getBatchId());
Assert.assertEquals(Long.valueOf(12L),reqEntity2.getBatchId());
Assert.assertEquals(BatchRequest.Type.DELETE.name(),reqEntity1.getRequestType());
Assert.assertEquals(BatchRequest.Type.POST.name(),reqEntity2.getRequestType());
Assert.assertEquals(requestExecution.getSchedule().getMinutes(),scheduleEntity.getMinutes());
Assert.assertEquals(requestExecution.getSchedule().getEndTime(),scheduleEntity.getEndTime());
}
Class: org.apache.ambari.server.state.ServiceComponentTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier compHosts=new HashMap();
compHosts.put("h1",sch);
component.addServiceComponentHosts(compHosts);
Assert.assertEquals(1,component.getServiceComponentHosts().size());
sch.persist();
ServiceComponent sc=service.getServiceComponent(componentName);
Assert.assertNotNull(sc);
sc.setDesiredState(State.INSTALLED);
sc.setDesiredStackVersion(new StackId("HDP-1.2.0"));
ServiceComponentResponse r=sc.convertToResponse();
Assert.assertEquals(sc.getClusterName(),r.getClusterName());
Assert.assertEquals(sc.getClusterId(),r.getClusterId().longValue());
Assert.assertEquals(sc.getName(),r.getComponentName());
Assert.assertEquals(sc.getServiceName(),r.getServiceName());
Assert.assertEquals(sc.getDesiredStackVersion().getStackId(),r.getDesiredStackVersion());
Assert.assertEquals(sc.getDesiredState().toString(),r.getDesiredState());
Assert.assertEquals(1,r.getTotalCount());
Assert.assertEquals(0,r.getStartedCount());
Assert.assertEquals(1,r.getInstalledCount());
StringBuilder sb=new StringBuilder();
sc.debugDump(sb);
Assert.assertFalse(sb.toString().isEmpty());
}
UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier compHosts=new HashMap();
compHosts.put("h1",sch1);
compHosts.put("h2",sch2);
compHosts.put("h3",failSch);
try {
sc.addServiceComponentHosts(compHosts);
fail("Expected error for dups");
}
catch ( Exception e) {
}
Assert.assertTrue(sc.getServiceComponentHosts().isEmpty());
compHosts.remove("h3");
sc.addServiceComponentHosts(compHosts);
Assert.assertEquals(2,sc.getServiceComponentHosts().size());
sch1.persist();
sch2.persist();
ServiceComponentHost schCheck=sc.getServiceComponentHost("h2");
Assert.assertNotNull(schCheck);
Assert.assertEquals("h2",schCheck.getHostName());
ServiceComponentHost sch3=serviceComponentHostFactory.createNew(sc,"h3");
sc.addServiceComponentHost(sch3);
sch3.persist();
Assert.assertNotNull(sc.getServiceComponentHost("h3"));
sch1.setDesiredStackVersion(new StackId("HDP-1.2.0"));
sch1.setState(State.STARTING);
sch1.setStackVersion(new StackId("HDP-1.2.0"));
sch1.setDesiredState(State.STARTED);
HostComponentDesiredStateDAO desiredStateDAO=injector.getInstance(HostComponentDesiredStateDAO.class);
HostComponentStateDAO liveStateDAO=injector.getInstance(HostComponentStateDAO.class);
HostComponentDesiredStateEntityPK dPK=new HostComponentDesiredStateEntityPK();
dPK.setClusterId(cluster.getClusterId());
dPK.setComponentName(componentName);
dPK.setHostId(hostEntity1.getHostId());
dPK.setServiceName(serviceName);
HostComponentDesiredStateEntity desiredStateEntity=desiredStateDAO.findByPK(dPK);
HostComponentStateEntity stateEntity=liveStateDAO.findByIndex(cluster.getClusterId(),serviceName,componentName,hostEntity1.getHostId());
ServiceComponentHost sch=serviceComponentHostFactory.createExisting(sc,stateEntity,desiredStateEntity);
Assert.assertNotNull(sch);
Assert.assertEquals(State.STARTING,sch.getState());
Assert.assertEquals(State.STARTED,sch.getDesiredState());
Assert.assertEquals("HDP-1.2.0",sch.getStackVersion().getStackId());
Assert.assertEquals("HDP-1.2.0",sch.getDesiredStackVersion().getStackId());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier TestInitializer InternalCallVerifier NullVerifier HybridVerifier BranchVerifier InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.state.ServiceInfoTest InternalCallVerifier BooleanVerifier servicePropertyList=Lists.newArrayList(p1,p2);
ServiceInfo serviceInfo=new ServiceInfo();
serviceInfo.setName("TEST_NAME");
serviceInfo.setVersion("TEST_VERSION");
serviceInfo.setServicePropertyList(servicePropertyList);
assertFalse("Service info should be in invalid state due to duplicate service property names !",serviceInfo.isValid());
assertTrue("Service info error collection should contain the name of the duplicate service property !",serviceInfo.getErrors().contains("Duplicate service property with name 'PROP1' found in " + serviceInfo.getName() + ":"+ serviceInfo.getVersion()+ " service definition !"));
}
InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier " + " 2.0 " + " "+ " "+ " 1.0 "+ " WITH_DUPLICATE_PROPS "+ " WITH_PROPS "+ " "+ " "+ " PROP1 "+ " VAL1 "+ " "+ " "+ " PROP1 "+ " VAL2 "+ " "+ " "+ " managed "+ " false "+ " "+ " "+ " "+ " "+ " ";
Map serviceInfoMap=getServiceInfo(serviceInfoXml);
ServiceInfo serviceInfo=serviceInfoMap.get("WITH_DUPLICATE_PROPS");
assertFalse("Service info should be in invalid state due to duplicate service property names !",serviceInfo.isValid());
assertTrue("Service info error collection should contain the name of the duplicate service property !",serviceInfo.getErrors().contains("Duplicate service property with name 'PROP1' found in " + serviceInfo.getName() + ":"+ serviceInfo.getVersion()+ " service definition !"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier servicePropertyList=Lists.newArrayList(p1,p2);
ServiceInfo serviceInfo=new ServiceInfo();
serviceInfo.setName("TEST_NAME");
serviceInfo.setVersion("TEST_VERSION");
serviceInfo.setServicePropertyList(servicePropertyList);
Map serviceProperties=serviceInfo.getServiceProperties();
assertTrue(serviceProperties.containsKey("PROP1"));
assertEquals("V1",serviceProperties.get("PROP1"));
assertTrue(serviceProperties.containsKey("PROP2"));
assertEquals("V2",serviceProperties.get("PROP2"));
assertTrue("true".equals(serviceProperties.get(ServiceInfo.DEFAULT_SERVICE_INSTALLABLE_PROPERTY.getKey())));
assertTrue("true".equals(serviceProperties.get(ServiceInfo.DEFAULT_SERVICE_MANAGED_PROPERTY.getKey())));
assertTrue("true".equals(serviceProperties.get(ServiceInfo.DEFAULT_SERVICE_MONITORED_PROPERTY.getKey())));
}
Class: org.apache.ambari.server.state.ServicePropertyInfoTest APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.state.ServiceTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier TestInitializer InternalCallVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier comps=new HashMap();
comps.put(sc1.getName(),sc1);
comps.put(sc2.getName(),sc2);
s.addServiceComponents(comps);
Assert.assertEquals(2,s.getServiceComponents().size());
Assert.assertNotNull(s.getServiceComponent(sc1.getName()));
Assert.assertNotNull(s.getServiceComponent(sc2.getName()));
try {
s.getServiceComponent(sc3.getName());
fail("Expected error when looking for invalid component");
}
catch ( Exception e) {
}
s.addServiceComponent(sc3);
sc1.persist();
sc2.persist();
sc3.persist();
ServiceComponent sc4=s.addServiceComponent("HDFS_CLIENT");
Assert.assertNotNull(s.getServiceComponent(sc4.getName()));
Assert.assertEquals(State.INIT,s.getServiceComponent("HDFS_CLIENT").getDesiredState());
Assert.assertTrue(sc4.isClientComponent());
sc4.persist();
Assert.assertEquals(4,s.getServiceComponents().size());
Assert.assertNotNull(s.getServiceComponent(sc3.getName()));
Assert.assertEquals(sc3.getName(),s.getServiceComponent(sc3.getName()).getName());
Assert.assertEquals(s.getName(),s.getServiceComponent(sc3.getName()).getServiceName());
Assert.assertEquals(cluster.getClusterName(),s.getServiceComponent(sc3.getName()).getClusterName());
sc4.setDesiredState(State.INSTALLING);
Assert.assertEquals(State.INSTALLING,s.getServiceComponent("HDFS_CLIENT").getDesiredState());
}
Class: org.apache.ambari.server.state.UpgradeHelperTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_test_checks"));
UpgradePack upgrade=upgrades.get("upgrade_test_checks");
assertNotNull(upgrade);
makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,DOWNGRADE_VERSION,Direction.DOWNGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(5,groups.size());
UpgradeGroupHolder zookeeperGroup=groups.get(3);
assertEquals("ZOOKEEPER",zookeeperGroup.name);
ManualTask manualTask=(ManualTask)zookeeperGroup.items.get(0).getTasks().get(0).getTasks().get(0);
assertEquals("This is a manual task with a placeholder of placeholder-rendered-properly",manualTask.message);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
assertNotNull(upgrade);
makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
UpgradeGroupHolder mastersGroup=groups.get(2);
assertEquals("CORE_MASTER",mastersGroup.name);
List orderedNameNodes=new LinkedList();
for ( StageWrapper sw : mastersGroup.items) {
if (sw.getType().equals(StageWrapper.Type.RESTART) && sw.getText().toLowerCase().contains("NameNode".toLowerCase())) {
for ( TaskWrapper tw : sw.getTasks()) {
for ( String hostName : tw.getHosts()) {
orderedNameNodes.add(hostName);
}
}
}
}
assertEquals(2,orderedNameNodes.size());
assertEquals("h2",orderedNameNodes.get(0));
assertEquals("h1",orderedNameNodes.get(1));
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
assertNotNull(upgrade);
assertTrue(upgrade.getType() == UpgradeType.ROLLING);
List upgradePackGroups=upgrade.getGroups(Direction.UPGRADE);
boolean foundService=false;
for ( Grouping group : upgradePackGroups) {
if (group.title.equals("Oozie")) {
foundService=true;
}
}
assertTrue(foundService);
makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
int numPrepareStages=0;
for ( UpgradeGroupHolder group : groups) {
if (group.name.equals("OOZIE")) {
assertTrue(group.items.size() > 0);
for ( StageWrapper sw : group.items) {
if (sw.getText().equalsIgnoreCase("Preparing Oozie Server on h2 (Batch 1 of 2)") || sw.getText().equalsIgnoreCase("Preparing Oozie Server on h3 (Batch 2 of 2)")) {
numPrepareStages++;
List taskWrappers=sw.getTasks();
assertEquals(1,taskWrappers.size());
List tasks=taskWrappers.get(0).getTasks();
assertEquals(1,taskWrappers.get(0).getHosts().size());
assertEquals(1,tasks.size());
ExecuteTask task=(ExecuteTask)tasks.get(0);
assertTrue("scripts/oozie_server.py".equalsIgnoreCase(task.script));
assertTrue("stop".equalsIgnoreCase(task.function));
}
if (sw.getText().equalsIgnoreCase("Preparing Oozie Server on h2")) {
numPrepareStages++;
List taskWrappers=sw.getTasks();
assertEquals(1,taskWrappers.size());
List tasks=taskWrappers.get(0).getTasks();
assertEquals(1,taskWrappers.get(0).getHosts().size());
assertEquals(1,tasks.size());
ExecuteTask task=(ExecuteTask)tasks.get(0);
assertTrue("scripts/oozie_server_upgrade.py".equalsIgnoreCase(task.script));
assertTrue("upgrade_oozie_database_and_sharelib".equalsIgnoreCase(task.function));
}
}
}
}
assertEquals(3,numPrepareStages);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
assertNotNull(upgrade);
makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,DOWNGRADE_VERSION,Direction.DOWNGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
assertEquals("PRE_CLUSTER",groups.get(0).name);
assertEquals("OOZIE",groups.get(1).name);
assertEquals("HIVE",groups.get(2).name);
assertEquals("CORE_SLAVES",groups.get(3).name);
assertEquals("CORE_MASTER",groups.get(4).name);
assertEquals("ZOOKEEPER",groups.get(5).name);
UpgradeGroupHolder postGroup=groups.get(6);
assertEquals("POST_CLUSTER",postGroup.name);
assertEquals("Finalize Downgrade",postGroup.title);
assertEquals(3,postGroup.items.size());
assertEquals("Confirm Finalize",postGroup.items.get(0).getText());
assertEquals("Execute HDFS Finalize",postGroup.items.get(1).getText());
assertEquals("Save Cluster State",postGroup.items.get(2).getText());
assertEquals(StageWrapper.Type.SERVER_SIDE_ACTION,postGroup.items.get(2).getType());
assertEquals(4,groups.get(0).items.size());
assertEquals(8,groups.get(1).items.size());
assertEquals(3,groups.get(2).items.size());
assertEquals(8,groups.get(3).items.size());
assertEquals(8,groups.get(4).items.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
ConfigUpgradePack cup=ambariMetaInfo.getConfigUpgradePack("HDP","2.1.1");
assertNotNull(upgrade);
Cluster cluster=makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
UpgradeGroupHolder hiveGroup=groups.get(4);
assertEquals("HIVE",hiveGroup.name);
ConfigureTask configureTask=(ConfigureTask)hiveGroup.items.get(2).getTasks().get(0).getTasks().get(0);
Map configProperties=configureTask.getConfigurationChanges(cluster,cup);
assertFalse(configProperties.isEmpty());
assertEquals(configProperties.get(ConfigureTask.PARAMETER_CONFIG_TYPE),"hive-site");
String configurationJson=configProperties.get(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS);
String transferJson=configProperties.get(ConfigureTask.PARAMETER_TRANSFERS);
assertNotNull(configurationJson);
assertNotNull(transferJson);
List keyValuePairs=m_gson.fromJson(configurationJson,new TypeToken>(){
}
.getType());
List transfers=m_gson.fromJson(transferJson,new TypeToken>(){
}
.getType());
assertEquals("fooKey",keyValuePairs.get(0).key);
assertEquals("fooValue",keyValuePairs.get(0).value);
assertEquals("fooKey2",keyValuePairs.get(1).key);
assertEquals("fooValue2",keyValuePairs.get(1).value);
assertEquals("fooKey3",keyValuePairs.get(2).key);
assertEquals("fooValue3",keyValuePairs.get(2).value);
assertEquals("copy-key",transfers.get(0).fromKey);
assertEquals("copy-key-to",transfers.get(0).toKey);
assertEquals("move-key",transfers.get(1).fromKey);
assertEquals("move-key-to",transfers.get(1).toKey);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
ServiceInfo si=ambariMetaInfo.getService("HDP","2.1.1","ZOOKEEPER");
si.setDisplayName("Zk");
ComponentInfo ci=si.getComponentByName("ZOOKEEPER_SERVER");
ci.setDisplayName("ZooKeeper1 Server2");
assertTrue(upgrades.containsKey("upgrade_server_action_test"));
UpgradePack upgrade=upgrades.get("upgrade_server_action_test");
assertNotNull(upgrade);
makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(1,groups.size());
UpgradeGroupHolder group=groups.get(0);
assertEquals("CLUSTER_SERVER_ACTIONS",group.name);
List stageWrappers=group.items;
assertEquals(6,stageWrappers.size());
assertEquals("Pre Upgrade",stageWrappers.get(0).getText());
assertEquals("Pre Upgrade Zookeeper",stageWrappers.get(1).getText());
assertEquals("Configuring",stageWrappers.get(2).getText());
assertEquals("Configuring HDFS",stageWrappers.get(3).getText());
assertEquals("Calculating Properties",stageWrappers.get(4).getText());
assertEquals("Calculating HDFS Properties",stageWrappers.get(5).getText());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","6");
host.setHostAttributes(hostAttributes);
host.persist();
clusters.mapHostToCluster(hostName,clusterName);
}
c.addService(serviceFactory.createNew(c,"HDFS"));
Service s=c.getService("HDFS");
ServiceComponent sc=s.addServiceComponent("NAMENODE");
sc.addServiceComponentHost("h1");
sc.addServiceComponentHost("h2");
List schs=c.getServiceComponentHosts("HDFS","NAMENODE");
assertEquals(2,schs.size());
HostsType type=new HostsType();
type.master="h1";
type.secondary="h2";
expect(m_masterHostResolver.getMasterAndHosts("ZOOKEEPER","ZOOKEEPER_SERVER")).andReturn(null).anyTimes();
expect(m_masterHostResolver.getMasterAndHosts("HDFS","NAMENODE")).andReturn(type).anyTimes();
expect(m_masterHostResolver.getCluster()).andReturn(c).anyTimes();
replay(m_masterHostResolver);
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,DOWNGRADE_VERSION,Direction.DOWNGRADE,UpgradeType.ROLLING);
Map upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_direction"));
UpgradePack upgrade=upgrades.get("upgrade_direction");
assertNotNull(upgrade);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(2,groups.size());
UpgradeGroupHolder group=groups.get(0);
assertEquals(1,group.items.size());
assertEquals("PRE_POST_CLUSTER",group.name);
group=groups.get(1);
assertEquals("POST_CLUSTER",group.name);
assertEquals(3,group.items.size());
StageWrapper stage=group.items.get(1);
assertEquals("NameNode Finalize",stage.getText());
assertEquals(1,stage.getTasks().size());
TaskWrapper task=stage.getTasks().get(0);
assertEquals(1,task.getHosts().size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
assertNotNull(upgrade);
makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
UpgradeGroupHolder zookeeperGroup=groups.get(1);
assertEquals("ZOOKEEPER",zookeeperGroup.name);
ManualTask manualTask=(ManualTask)zookeeperGroup.items.get(0).getTasks().get(0).getTasks().get(0);
assertEquals("This is a manual task with a placeholder of placeholder-rendered-properly",manualTask.message);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
ConfigUpgradePack cup=ambariMetaInfo.getConfigUpgradePack("HDP","2.1.1");
assertNotNull(upgrade);
Cluster cluster=makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
UpgradeGroupHolder hiveGroup=groups.get(4);
assertEquals("HIVE",hiveGroup.name);
ConfigureTask configureTask=(ConfigureTask)hiveGroup.items.get(2).getTasks().get(0).getTasks().get(0);
Map hiveConfigs=new HashMap();
hiveConfigs.put("hive.server2.transport.mode","http");
hiveConfigs.put("hive.server2.thrift.port","10001");
hiveConfigs.put("condition","1");
ConfigurationRequest configurationRequest=new ConfigurationRequest();
configurationRequest.setClusterName(cluster.getClusterName());
configurationRequest.setType("hive-site");
configurationRequest.setVersionTag("version2");
configurationRequest.setProperties(hiveConfigs);
final ClusterRequest clusterRequest=new ClusterRequest(cluster.getClusterId(),cluster.getClusterName(),cluster.getDesiredStackVersion().getStackVersion(),null);
clusterRequest.setDesiredConfig(Collections.singletonList(configurationRequest));
m_managementController.updateClusters(new HashSet(){
{
add(clusterRequest);
}
}
,null);
Map configProperties=configureTask.getConfigurationChanges(cluster,cup);
assertFalse(configProperties.isEmpty());
assertEquals(configProperties.get(ConfigureTask.PARAMETER_CONFIG_TYPE),"hive-site");
String configurationJson=configProperties.get(ConfigureTask.PARAMETER_TRANSFERS);
assertNotNull(configurationJson);
List transfers=m_gson.fromJson(configurationJson,new TypeToken>(){
}
.getType());
assertEquals(10,transfers.size());
assertEquals("copy-key",transfers.get(0).fromKey);
assertEquals("copy-key-to",transfers.get(0).toKey);
assertEquals("move-key",transfers.get(1).fromKey);
assertEquals("move-key-to",transfers.get(1).toKey);
assertEquals("delete-key",transfers.get(2).deleteKey);
assertEquals("delete-http",transfers.get(3).deleteKey);
assertEquals("delete-null-if-value",transfers.get(4).deleteKey);
assertEquals("delete-blank-if-key",transfers.get(5).deleteKey);
assertEquals("delete-blank-if-type",transfers.get(6).deleteKey);
assertEquals("delete-thrift",transfers.get(7).deleteKey);
assertEquals("delete-if-key-present",transfers.get(8).deleteKey);
assertEquals("delete-if-key-absent",transfers.get(9).deleteKey);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("foo","bar");
assertTrue(upgrades.isEmpty());
upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
ServiceInfo si=ambariMetaInfo.getService("HDP","2.1.1","ZOOKEEPER");
si.setDisplayName("Zk");
ComponentInfo ci=si.getComponentByName("ZOOKEEPER_SERVER");
ci.setDisplayName("ZooKeeper1 Server2");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
assertNotNull(upgrade);
makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
assertEquals("PRE_CLUSTER",groups.get(0).name);
assertEquals("ZOOKEEPER",groups.get(1).name);
assertEquals("CORE_MASTER",groups.get(2).name);
assertEquals("CORE_SLAVES",groups.get(3).name);
assertEquals("HIVE",groups.get(4).name);
assertEquals("OOZIE",groups.get(5).name);
UpgradeGroupHolder holder=groups.get(2);
boolean found=false;
for ( StageWrapper sw : holder.items) {
if (sw.getTasksJson().contains("Upgrading your database")) {
found=true;
}
}
assertTrue("Expected to find replaced text for Upgrading",found);
UpgradeGroupHolder group=groups.get(1);
assertTrue(group.items.get(1).getText().contains("ZooKeeper1 Server2"));
assertEquals(group.items.get(5).getText(),"Service Check Zk");
group=groups.get(3);
assertEquals(8,group.items.size());
StageWrapper sw=group.items.get(3);
assertEquals("Validate Partial Upgrade",sw.getText());
assertEquals(1,sw.getTasks().size());
assertEquals(1,sw.getTasks().get(0).getTasks().size());
Task t=sw.getTasks().get(0).getTasks().get(0);
assertEquals(ManualTask.class,t.getClass());
ManualTask mt=(ManualTask)t;
assertTrue(mt.message.contains("DataNode and NodeManager"));
assertNotNull(mt.structuredOut);
assertTrue(mt.structuredOut.contains("DATANODE"));
assertTrue(mt.structuredOut.contains("NODEMANAGER"));
UpgradeGroupHolder postGroup=groups.get(6);
assertEquals("POST_CLUSTER",postGroup.name);
assertEquals("Finalize Upgrade",postGroup.title);
assertEquals(3,postGroup.items.size());
assertEquals("Confirm Finalize",postGroup.items.get(0).getText());
assertEquals("Execute HDFS Finalize",postGroup.items.get(1).getText());
assertEquals("Save Cluster State",postGroup.items.get(2).getText());
assertEquals(StageWrapper.Type.SERVER_SIDE_ACTION,postGroup.items.get(2).getType());
assertEquals(4,groups.get(0).items.size());
assertEquals(6,groups.get(1).items.size());
assertEquals(9,groups.get(2).items.size());
assertEquals(8,groups.get(3).items.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("foo","bar");
assertTrue(upgrades.isEmpty());
upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
ServiceInfo si=ambariMetaInfo.getService("HDP","2.1.1","ZOOKEEPER");
si.setDisplayName("Zk");
ComponentInfo ci=si.getComponentByName("ZOOKEEPER_SERVER");
ci.setDisplayName("ZooKeeper1 Server2");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
assertNotNull(upgrade);
Cluster cluster=makeCluster();
Host hostInMaintenanceMode=cluster.getHosts().iterator().next();
hostInMaintenanceMode.setMaintenanceState(cluster.getClusterId(),MaintenanceState.ON);
MasterHostResolver masterHostResolver=new MasterHostResolver(null,cluster,"");
UpgradeContext context=new UpgradeContext(masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
for ( UpgradeGroupHolder group : groups) {
for ( StageWrapper stageWrapper : group.items) {
Set hosts=stageWrapper.getHosts();
assertFalse(hosts.contains(hostInMaintenanceMode.getHostName()));
}
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
ServiceInfo si=ambariMetaInfo.getService("HDP","2.1.1","ZOOKEEPER");
si.setDisplayName("Zk");
ComponentInfo ci=si.getComponentByName("ZOOKEEPER_SERVER");
ci.setDisplayName("ZooKeeper1 Server2");
assertTrue(upgrades.containsKey("upgrade_to_new_stack"));
UpgradePack upgrade=upgrades.get("upgrade_to_new_stack");
assertNotNull(upgrade);
makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(6,groups.size());
assertEquals("PRE_CLUSTER",groups.get(0).name);
assertEquals("ZOOKEEPER",groups.get(1).name);
assertEquals("CORE_MASTER",groups.get(2).name);
assertEquals("CORE_SLAVES",groups.get(3).name);
assertEquals("HIVE",groups.get(4).name);
UpgradeGroupHolder holder=groups.get(2);
boolean found=false;
for ( StageWrapper sw : holder.items) {
if (sw.getTasksJson().contains("Upgrading your database")) {
found=true;
}
}
assertTrue("Expected to find replaced text for Upgrading",found);
UpgradeGroupHolder group=groups.get(1);
assertTrue(group.items.get(1).getText().contains("ZooKeeper1 Server2"));
assertEquals(group.items.get(4).getText(),"Service Check Zk");
group=groups.get(3);
assertEquals(8,group.items.size());
StageWrapper sw=group.items.get(3);
assertEquals("Validate Partial Upgrade",sw.getText());
assertEquals(1,sw.getTasks().size());
assertEquals(1,sw.getTasks().get(0).getTasks().size());
Task t=sw.getTasks().get(0).getTasks().get(0);
assertEquals(ManualTask.class,t.getClass());
ManualTask mt=(ManualTask)t;
assertTrue(mt.message.contains("DataNode and NodeManager"));
assertNotNull(mt.structuredOut);
assertTrue(mt.structuredOut.contains("DATANODE"));
assertTrue(mt.structuredOut.contains("NODEMANAGER"));
UpgradeGroupHolder postGroup=groups.get(5);
assertEquals(postGroup.name,"POST_CLUSTER");
assertEquals(postGroup.title,"Finalize Upgrade");
assertEquals(4,postGroup.items.size());
assertEquals("Confirm Finalize",postGroup.items.get(0).getText());
assertEquals("Execute HDFS Finalize",postGroup.items.get(1).getText());
assertEquals("Save Cluster State",postGroup.items.get(2).getText());
assertEquals(StageWrapper.Type.SERVER_SIDE_ACTION,postGroup.items.get(2).getType());
assertEquals("Run On All 2.2.1.0-1234",postGroup.items.get(3).getText());
assertEquals(1,postGroup.items.get(3).getTasks().size());
Set hosts=postGroup.items.get(3).getTasks().get(0).getHosts();
assertNotNull(hosts);
assertEquals(4,hosts.size());
assertEquals(4,groups.get(0).items.size());
assertEquals(5,groups.get(1).items.size());
assertEquals(9,groups.get(2).items.size());
assertEquals(8,groups.get(3).items.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
ConfigUpgradePack cup=ambariMetaInfo.getConfigUpgradePack("HDP","2.1.1");
assertNotNull(upgrade);
Cluster cluster=makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
UpgradeGroupHolder hiveGroup=groups.get(4);
assertEquals("HIVE",hiveGroup.name);
ConfigureTask configureTask=(ConfigureTask)hiveGroup.items.get(1).getTasks().get(0).getTasks().get(0);
Map configProperties=configureTask.getConfigurationChanges(cluster,cup);
assertFalse(configProperties.isEmpty());
assertEquals(configProperties.get(ConfigureTask.PARAMETER_CONFIG_TYPE),"hive-site");
String configurationJson=configProperties.get(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS);
assertNotNull(configurationJson);
List keyValuePairs=m_gson.fromJson(configurationJson,new TypeToken>(){
}
.getType());
assertEquals("hive.server2.thrift.port",keyValuePairs.get(0).key);
assertEquals("10010",keyValuePairs.get(0).value);
Map hiveConfigs=new HashMap();
hiveConfigs.put("hive.server2.transport.mode","http");
hiveConfigs.put("hive.server2.thrift.port","10001");
ConfigurationRequest configurationRequest=new ConfigurationRequest();
configurationRequest.setClusterName(cluster.getClusterName());
configurationRequest.setType("hive-site");
configurationRequest.setVersionTag("version2");
configurationRequest.setProperties(hiveConfigs);
final ClusterRequest clusterRequest=new ClusterRequest(cluster.getClusterId(),cluster.getClusterName(),cluster.getDesiredStackVersion().getStackVersion(),null);
clusterRequest.setDesiredConfig(Collections.singletonList(configurationRequest));
m_managementController.updateClusters(new HashSet(){
{
add(clusterRequest);
}
}
,null);
configProperties=configureTask.getConfigurationChanges(cluster,cup);
assertFalse(configProperties.isEmpty());
assertEquals(configProperties.get(ConfigureTask.PARAMETER_CONFIG_TYPE),"hive-site");
configurationJson=configProperties.get(ConfigureTask.PARAMETER_KEY_VALUE_PAIRS);
assertNotNull(configurationJson);
keyValuePairs=m_gson.fromJson(configurationJson,new TypeToken>(){
}
.getType());
assertEquals("hive.server2.http.port",keyValuePairs.get(0).key);
assertEquals("10011",keyValuePairs.get(0).value);
}
InternalCallVerifier EqualityVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","6");
host.setHostAttributes(hostAttributes);
host.persist();
clusters.mapHostToCluster(hostName,clusterName);
}
c.addService(serviceFactory.createNew(c,"ZOOKEEPER"));
Service s=c.getService("ZOOKEEPER");
ServiceComponent sc=s.addServiceComponent("ZOOKEEPER_SERVER");
ServiceComponentHost sch1=sc.addServiceComponentHost("h1");
sch1.setVersion("2.1.1.0-1234");
ServiceComponentHost sch2=sc.addServiceComponentHost("h2");
sch2.setVersion("2.1.1.0-1234");
List schs=c.getServiceComponentHosts("ZOOKEEPER","ZOOKEEPER_SERVER");
assertEquals(2,schs.size());
MasterHostResolver mhr=new MasterHostResolver(null,c,"2.1.1.0-1234");
HostsType ht=mhr.getMasterAndHosts("ZOOKEEPER","ZOOKEEPER_SERVER");
assertEquals(0,ht.hosts.size());
sch2.setUpgradeState(UpgradeState.FAILED);
ht=mhr.getMasterAndHosts("ZOOKEEPER","ZOOKEEPER_SERVER");
assertEquals(1,ht.hosts.size());
assertEquals("h2",ht.hosts.iterator().next());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("foo","bar");
assertTrue(upgrades.isEmpty());
upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
assertNotNull(upgrade);
Cluster cluster=makeCluster(false);
Clusters clusters=injector.getInstance(Clusters.class);
Host h4=clusters.getHost("h4");
h4.setState(HostState.HEARTBEAT_LOST);
h4.persist();
List schs=cluster.getServiceComponentHosts("h4");
assertEquals(1,schs.size());
assertEquals(HostState.HEARTBEAT_LOST,schs.get(0).getHostState());
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
assertEquals("PRE_CLUSTER",groups.get(0).name);
assertEquals("ZOOKEEPER",groups.get(1).name);
assertEquals("CORE_MASTER",groups.get(2).name);
assertEquals("CORE_SLAVES",groups.get(3).name);
assertEquals("HIVE",groups.get(4).name);
assertEquals("OOZIE",groups.get(5).name);
UpgradeGroupHolder postGroup=groups.get(6);
assertEquals("POST_CLUSTER",postGroup.name);
assertEquals("Finalize Upgrade",postGroup.title);
assertEquals(3,postGroup.items.size());
assertEquals("Confirm Finalize",postGroup.items.get(0).getText());
assertEquals("Execute HDFS Finalize",postGroup.items.get(1).getText());
assertEquals("Save Cluster State",postGroup.items.get(2).getText());
assertEquals(StageWrapper.Type.SERVER_SIDE_ACTION,postGroup.items.get(2).getType());
assertEquals(6,groups.get(1).items.size());
assertEquals(9,groups.get(2).items.size());
assertEquals(7,groups.get(3).items.size());
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.2.0");
assertTrue(upgrades.containsKey("upgrade_test_checks"));
UpgradePack upgrade=upgrades.get("upgrade_test_checks");
assertNotNull(upgrade);
Cluster c=makeCluster();
Set additionalServices=new HashSet(){
{
add("HBASE");
add("PIG");
add("TEZ");
add("AMBARI_METRICS");
}
}
;
for ( String service : additionalServices) {
c.addService(service);
}
int numServiceChecksExpected=0;
Collection services=c.getServices().values();
for ( Service service : services) {
ServiceInfo si=ambariMetaInfo.getService(c.getCurrentStackVersion().getStackName(),c.getCurrentStackVersion().getStackVersion(),service.getName());
if (null == si.getCommandScript()) {
continue;
}
if (service.getName().equalsIgnoreCase("TEZ")) {
assertTrue("Expect Tez to not have any service checks",false);
}
if (service.getName().equalsIgnoreCase("AMBARI_METRICS")) {
continue;
}
numServiceChecksExpected++;
}
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_22,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(7,groups.size());
UpgradeGroupHolder holder=groups.get(3);
assertEquals(holder.name,"SERVICE_CHECK_1");
assertEquals(7,holder.items.size());
int numServiceChecksActual=0;
for ( StageWrapper sw : holder.items) {
for ( Service service : services) {
Pattern p=Pattern.compile(".*" + service.getName(),Pattern.CASE_INSENSITIVE);
Matcher matcher=p.matcher(sw.getText());
if (matcher.matches()) {
numServiceChecksActual++;
continue;
}
}
}
assertEquals(numServiceChecksActual,numServiceChecksExpected);
UpgradeGroupHolder zookeeperGroup=groups.get(1);
assertEquals("ZOOKEEPER",zookeeperGroup.name);
ManualTask manualTask=(ManualTask)zookeeperGroup.items.get(0).getTasks().get(0).getTasks().get(0);
assertEquals("This is a manual task with a placeholder of placeholder-rendered-properly",manualTask.message);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.containsKey("upgrade_bucket_test"));
UpgradePack upgrade=upgrades.get("upgrade_bucket_test");
assertNotNull(upgrade);
makeCluster();
UpgradeContext context=new UpgradeContext(m_masterHostResolver,HDP_21,HDP_21,UPGRADE_VERSION,Direction.UPGRADE,UpgradeType.ROLLING);
List groups=m_upgradeHelper.createSequence(upgrade,context);
assertEquals(1,groups.size());
UpgradeGroupHolder group=groups.iterator().next();
assertEquals(22,group.items.size());
}
Class: org.apache.ambari.server.state.action.JobTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.state.alerts.AggregateAlertListenerTest InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.state.alerts.AlertDefinitionEqualityTest InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.state.alerts.AlertDefinitionHashTest InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier hosts=new HashSet();
hosts.add(HOSTNAME);
m_hash.enqueueAgentCommands(1L,hosts);
assertEquals(1,actionQueue.size(HOSTNAME));
assertEquals(1,actionQueue.size("anotherHost"));
}
InternalCallVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier invalidatedHosts=m_hash.invalidateHosts(m_hdfsHost);
assertFalse(m_hash.isHashCached(CLUSTERNAME,HOSTNAME));
assertNotNull(invalidatedHosts);
assertEquals(1,invalidatedHosts.size());
assertTrue(invalidatedHosts.contains(HOSTNAME));
}
InternalCallVerifier EqualityVerifier associatedHosts=m_hash.getAssociatedHosts(m_mockCluster,SourceType.AGGREGATE,"definitionName","HDFS",null);
assertEquals(0,associatedHosts.size());
associatedHosts=m_hash.getAssociatedHosts(m_mockCluster,SourceType.PORT,"definitionName","HDFS",null);
assertEquals(1,associatedHosts.size());
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier definitions=m_hash.getAlertDefinitions(CLUSTERNAME,HOSTNAME);
assertEquals(3,definitions.size());
}
Class: org.apache.ambari.server.state.alerts.AlertEventPublisherTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier TestInitializer InternalCallVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.state.alerts.AlertReceivedListenerTest InternalCallVerifier EqualityVerifier allCurrent=m_dao.findCurrent();
assertEquals(1,allCurrent.size());
alert1.setComponent("INVALID");
m_dao.removeCurrentByHost(HOST1);
allCurrent=m_dao.findCurrent();
assertEquals(0,allCurrent.size());
listener.onAlertEvent(event1);
allCurrent=m_dao.findCurrent();
assertEquals(0,allCurrent.size());
}
InternalCallVerifier EqualityVerifier allCurrent=m_dao.findCurrent();
assertEquals(0,allCurrent.size());
}
InternalCallVerifier EqualityVerifier allCurrent=m_dao.findCurrent();
assertEquals(1,allCurrent.size());
AlertDefinitionEntity definition=m_definitionDao.findByName(m_cluster.getClusterId(),definitionName);
definition.setEnabled(false);
m_definitionDao.merge(definition);
m_dao.removeCurrentDisabledAlerts();
allCurrent=m_dao.findCurrent();
assertEquals(0,allCurrent.size());
listener.onAlertEvent(event1);
allCurrent=m_dao.findCurrent();
assertEquals(0,allCurrent.size());
}
InternalCallVerifier EqualityVerifier allCurrent=m_dao.findCurrent();
assertEquals(1,allCurrent.size());
alert1.setHostName("INVALID");
m_dao.removeCurrentByHost(HOST1);
allCurrent=m_dao.findCurrent();
assertEquals(0,allCurrent.size());
listener.onAlertEvent(event1);
allCurrent=m_dao.findCurrent();
assertEquals(0,allCurrent.size());
}
Class: org.apache.ambari.server.state.alerts.AlertStateChangedEventTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.state.alerts.InitialAlertEventTest TestInitializer InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.state.cluster.AlertDataManagerTest InternalCallVerifier EqualityVerifier notices=m_dispatchDao.findAllNotices();
assertEquals(0,notices.size());
List definitions=m_definitionDao.findAll(m_cluster.getClusterId());
AlertDefinitionEntity definition=definitions.get(0);
AlertHistoryEntity history=new AlertHistoryEntity();
history.setServiceName(definition.getServiceName());
history.setClusterId(m_cluster.getClusterId());
history.setAlertDefinition(definition);
history.setAlertLabel(definition.getDefinitionName());
history.setAlertText(definition.getDefinitionName());
history.setAlertTimestamp(System.currentTimeMillis());
history.setHostName(HOST1);
history.setAlertState(AlertState.OK);
m_dao.create(history);
List histories=m_dao.findAll(m_cluster.getClusterId());
assertEquals(1,histories.size());
AlertCurrentEntity currentAlert=new AlertCurrentEntity();
currentAlert.setAlertHistory(histories.get(0));
currentAlert.setMaintenanceState(MaintenanceState.OFF);
currentAlert.setOriginalTimestamp(System.currentTimeMillis());
currentAlert.setLatestTimestamp(System.currentTimeMillis());
m_dao.create(currentAlert);
AlertTargetEntity target=m_helper.createAlertTarget();
Set targets=new HashSet();
targets.add(target);
AlertGroupEntity group=m_helper.createAlertGroup(m_cluster.getClusterId(),targets);
group.addAlertDefinition(definitions.get(0));
m_dispatchDao.merge(group);
Alert alert1=new Alert(ALERT_DEFINITION,null,SERVICE,COMPONENT,HOST1,AlertState.OK);
AlertStateChangeEvent event=new AlertStateChangeEvent(m_cluster.getClusterId(),alert1,currentAlert,AlertState.CRITICAL);
AlertStateChangedListener listener=m_injector.getInstance(AlertStateChangedListener.class);
listener.onAlertEvent(event);
notices=m_dispatchDao.findAllNotices();
assertEquals(1,notices.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier ref=new AtomicReference();
publisher.register(new TestListener(){
@Override @Subscribe public void catchIt( AlertReceivedEvent event){
ref.set(event.getAlert());
}
}
);
AlertAggregateListener listener=m_injector.getInstance(AlertAggregateListener.class);
AlertDefinitionFactory factory=new AlertDefinitionFactory();
AggregateDefinitionMapping aggregateMapping=m_injector.getInstance(AggregateDefinitionMapping.class);
AlertDefinition aggregateDefinition=factory.coerce(aggDef);
aggregateMapping.registerAggregate(m_cluster.getClusterId(),aggregateDefinition);
Assert.assertEquals(aggregateDefinition,aggregateMapping.getAggregateDefinitions(m_cluster.getClusterId()).get(0));
Assert.assertEquals(definition.getDefinitionName(),aggregateMapping.getAlertsWithAggregates(m_cluster.getClusterId()).get(0));
AggregateSource as=(AggregateSource)aggregateDefinition.getSource();
AlertDefinition aggregatedDefinition=aggregateMapping.getAggregateDefinition(m_cluster.getClusterId(),as.getAlertName());
assertNotNull(aggregatedDefinition);
Alert alert=new Alert(definition.getDefinitionName(),null,definition.getServiceName(),definition.getComponentName(),"h1",AlertState.OK);
AlertCurrentEntity current=m_dao.findCurrentByHostAndName(m_cluster.getClusterId(),"h1",definition.getDefinitionName());
AlertStateChangeEvent event=new AlertStateChangeEvent(m_cluster.getClusterId(),alert,current,AlertState.OK);
listener.onAlertStateChangeEvent(event);
assertNotNull(ref.get());
assertEquals(AlertState.OK,ref.get().getState());
assertTrue(ref.get().getText().indexOf("0/4") > -1);
current.getAlertHistory().setAlertState(AlertState.CRITICAL);
m_dao.merge(current.getAlertHistory());
listener.onAlertStateChangeEvent(event);
assertEquals("aggregate_test",ref.get().getName());
assertEquals(AlertState.OK,ref.get().getState());
assertTrue(ref.get().getText().indexOf("1/4") > -1);
current=m_dao.findCurrentByHostAndName(m_cluster.getClusterId(),"h2",definition.getDefinitionName());
current.getAlertHistory().setAlertState(AlertState.WARNING);
m_dao.merge(current.getAlertHistory());
listener.onAlertStateChangeEvent(event);
assertEquals("aggregate_test",ref.get().getName());
assertEquals(AlertState.WARNING,ref.get().getState());
assertTrue(ref.get().getText().indexOf("2/4") > -1);
current=m_dao.findCurrentByHostAndName(m_cluster.getClusterId(),"h3",definition.getDefinitionName());
current.getAlertHistory().setAlertState(AlertState.CRITICAL);
m_dao.merge(current.getAlertHistory());
listener.onAlertStateChangeEvent(event);
assertEquals("aggregate_test",ref.get().getName());
assertEquals(AlertState.CRITICAL,ref.get().getState());
assertTrue(ref.get().getText().indexOf("3/4") > -1);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier allCurrent=m_dao.findCurrentByService(m_cluster.getClusterId(),SERVICE);
assertEquals(2,allCurrent.size());
List allHistory=m_dao.findAll(m_cluster.getClusterId());
assertEquals(2,allHistory.size());
AlertCurrentEntity current=m_dao.findCurrentByHostAndName(m_cluster.getClusterId(),HOST1,ALERT_DEFINITION);
assertNotNull(current);
assertEquals(HOST1,current.getAlertHistory().getHostName());
assertEquals(ALERT_DEFINITION,current.getAlertHistory().getAlertDefinition().getDefinitionName());
assertEquals(ALERT_LABEL,current.getAlertHistory().getAlertLabel());
assertEquals("Component component1 is OK",current.getAlertHistory().getAlertText());
assertEquals(current.getAlertHistory().getAlertState(),AlertState.OK);
assertEquals(1L,current.getOriginalTimestamp().longValue());
assertEquals(1L,current.getLatestTimestamp().longValue());
Long currentId=current.getAlertId();
Long historyId=current.getAlertHistory().getAlertId();
Alert alert3=new Alert(ALERT_DEFINITION,null,SERVICE,COMPONENT,HOST1,AlertState.OK);
alert3.setLabel(ALERT_LABEL);
alert3.setText("Component component1 is OK");
alert3.setTimestamp(2L);
alert3.setCluster(m_cluster.getClusterName());
AlertReceivedEvent event3=new AlertReceivedEvent(m_cluster.getClusterId(),alert3);
listener.onAlertEvent(event3);
current=m_dao.findCurrentByHostAndName(m_cluster.getClusterId(),HOST1,ALERT_DEFINITION);
assertNotNull(current);
assertEquals(currentId,current.getAlertId());
assertEquals(historyId,current.getAlertHistory().getAlertId());
assertEquals(HOST1,current.getAlertHistory().getHostName());
assertEquals(ALERT_DEFINITION,current.getAlertHistory().getAlertDefinition().getDefinitionName());
assertEquals(ALERT_LABEL,current.getAlertHistory().getAlertLabel());
assertEquals("Component component1 is OK",current.getAlertHistory().getAlertText());
assertEquals(current.getAlertHistory().getAlertState(),AlertState.OK);
assertEquals(1L,current.getOriginalTimestamp().longValue());
assertEquals(2L,current.getLatestTimestamp().longValue());
allCurrent=m_dao.findCurrentByService(m_cluster.getClusterId(),SERVICE);
assertEquals(2,allCurrent.size());
allHistory=m_dao.findAll(m_cluster.getClusterId());
assertEquals(2,allHistory.size());
Alert alert4=new Alert(ALERT_DEFINITION,null,SERVICE,COMPONENT,HOST1,AlertState.WARNING);
alert4.setLabel(ALERT_LABEL);
alert4.setText("Component component1 is about to go down");
alert4.setTimestamp(3L);
alert4.setCluster(m_cluster.getClusterName());
AlertReceivedEvent event4=new AlertReceivedEvent(m_cluster.getClusterId(),alert4);
listener.onAlertEvent(event4);
current=m_dao.findCurrentByHostAndName(m_cluster.getClusterId(),HOST1,ALERT_DEFINITION);
assertNotNull(current);
assertEquals(current.getAlertId(),currentId);
assertFalse(historyId.equals(current.getAlertHistory().getAlertId()));
assertEquals(HOST1,current.getAlertHistory().getHostName());
assertEquals(ALERT_DEFINITION,current.getAlertHistory().getAlertDefinition().getDefinitionName());
assertEquals(ALERT_LABEL,current.getAlertHistory().getAlertLabel());
assertEquals("Component component1 is about to go down",current.getAlertHistory().getAlertText());
assertEquals(current.getAlertHistory().getAlertState(),AlertState.WARNING);
assertEquals(3L,current.getOriginalTimestamp().longValue());
assertEquals(3L,current.getLatestTimestamp().longValue());
allCurrent=m_dao.findCurrentByService(m_cluster.getClusterId(),SERVICE);
assertEquals(2,allCurrent.size());
allHistory=m_dao.findAll(m_cluster.getClusterId());
assertEquals(3,allHistory.size());
}
Class: org.apache.ambari.server.state.cluster.ClusterDeadlockTest BranchVerifier InternalCallVerifier BooleanVerifier threads=new ArrayList();
for (int i=0; i < 5; i++) {
ServiceComponentReaderWriterThread thread=new ServiceComponentReaderWriterThread();
thread.setDataNodeComponent(dataNodeComponent);
thread.setNameNodeComponent(nameNodeComponent);
thread.start();
threads.add(thread);
}
DeadlockWarningThread wt=new DeadlockWarningThread(threads);
while (true) {
if (!wt.isAlive()) {
break;
}
}
if (wt.isDeadlocked()) {
Assert.assertFalse(wt.getErrorMessages().toString(),wt.isDeadlocked());
}
else {
Assert.assertFalse(wt.isDeadlocked());
}
}
BranchVerifier InternalCallVerifier BooleanVerifier threads=new ArrayList();
for (int i=0; i < NUMBER_OF_THREADS; i++) {
DeadlockExerciserThread thread=new DeadlockExerciserThread();
thread.setCluster(cluster);
thread.setService(service);
thread.setDataNodeComponent(dataNodeComponent);
thread.setNameNodeComponent(nameNodeComponent);
thread.setNameNodeSCH(nameNodeSCH);
thread.setDataNodeSCH(dataNodeSCH);
thread.start();
threads.add(thread);
}
DeadlockWarningThread wt=new DeadlockWarningThread(threads);
while (true) {
if (!wt.isAlive()) {
break;
}
}
if (wt.isDeadlocked()) {
Assert.assertFalse(wt.getErrorMessages().toString(),wt.isDeadlocked());
}
else {
Assert.assertFalse(wt.isDeadlocked());
}
}
BranchVerifier InternalCallVerifier BooleanVerifier serviceComponentHosts=new ArrayList();
for ( String hostName : hostNames) {
serviceComponentHosts.add(createNewServiceComponentHost("HDFS","NAMENODE",hostName));
serviceComponentHosts.add(createNewServiceComponentHost("HDFS","DATANODE",hostName));
}
((ClusterImpl)cluster).loadServiceHostComponents();
List threads=new ArrayList();
for (int i=0; i < NUMBER_OF_THREADS; i++) {
ClusterReaderThread clusterReaderThread=new ClusterReaderThread();
ClusterWriterThread clusterWriterThread=new ClusterWriterThread();
ServiceComponentRestartThread schWriterThread=new ServiceComponentRestartThread(serviceComponentHosts);
threads.add(clusterReaderThread);
threads.add(clusterWriterThread);
threads.add(schWriterThread);
clusterReaderThread.start();
clusterWriterThread.start();
schWriterThread.start();
}
DeadlockWarningThread wt=new DeadlockWarningThread(threads);
while (true) {
if (!wt.isAlive()) {
break;
}
}
if (wt.isDeadlocked()) {
Assert.assertFalse(wt.getErrorMessages().toString(),wt.isDeadlocked());
}
else {
Assert.assertFalse(wt.isDeadlocked());
}
}
BranchVerifier InternalCallVerifier BooleanVerifier threads=new ArrayList();
for (int i=0; i < NUMBER_OF_THREADS; i++) {
ClusterDesiredConfigsReaderThread readerThread=null;
for (int j=0; j < NUMBER_OF_THREADS; j++) {
readerThread=new ClusterDesiredConfigsReaderThread();
threads.add(readerThread);
}
for ( Config config : cluster.getAllConfigs()) {
ConfigUpdaterThread configUpdaterThread=new ConfigUpdaterThread(config);
threads.add(configUpdaterThread);
}
}
for ( Thread thread : threads) {
thread.start();
}
DeadlockWarningThread wt=new DeadlockWarningThread(threads);
while (true) {
if (!wt.isAlive()) {
break;
}
}
if (wt.isDeadlocked()) {
Assert.assertFalse(wt.getErrorMessages().toString(),wt.isDeadlocked());
}
else {
Assert.assertFalse(wt.isDeadlocked());
}
}
Class: org.apache.ambari.server.state.cluster.ClusterImplTest InternalCallVerifier EqualityVerifier attributes=new HashMap();
attributes.put("foo","bar");
AmbariSessionManager sessionManager=createMock(AmbariSessionManager.class);
ClusterImpl cluster=createMockBuilder(ClusterImpl.class).addMockedMethod("getSessionManager").addMockedMethod("getClusterName").createMock();
expect(cluster.getSessionManager()).andReturn(sessionManager).anyTimes();
expect(cluster.getClusterName()).andReturn("c1").anyTimes();
expect(sessionManager.getAttribute("cluster_session_attributes:c1")).andReturn(attributes);
expect(sessionManager.getAttribute("cluster_session_attributes:c1")).andReturn(null);
replay(sessionManager,cluster);
assertEquals(attributes,cluster.getSessionAttributes());
assertEquals(Collections.emptyMap(),cluster.getSessionAttributes());
verify(sessionManager,cluster);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier UtilityVerifier InternalCallVerifier BooleanVerifier HybridVerifier Class: org.apache.ambari.server.state.cluster.ClusterTest InternalCallVerifier EqualityVerifier scHosts;
scHosts=c1.getServiceComponentHosts("HDFS","DATANODE");
Assert.assertEquals(2,scHosts.size());
scHosts=c1.getServiceComponentHosts("HDFS","UNKNOWN COMPONENT");
Assert.assertEquals(0,scHosts.size());
scHosts=c1.getServiceComponentHosts("UNKNOWN SERVICE","DATANODE");
Assert.assertEquals(0,scHosts.size());
scHosts=c1.getServiceComponentHosts("UNKNOWN SERVICE","UNKNOWN COMPONENT");
Assert.assertEquals(0,scHosts.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","5.9");
h.setHostAttributes(hostAttributes);
h.persist();
}
String v1="2.0.5-1";
String v2="2.0.5-2";
c1.setDesiredStackVersion(stackId);
RepositoryVersionEntity rve1=helper.getOrCreateRepositoryVersion(stackId,v1);
RepositoryVersionEntity rve2=helper.getOrCreateRepositoryVersion(stackId,v2);
c1.setCurrentStackVersion(stackId);
c1.createClusterVersion(stackId,v1,"admin",RepositoryVersionState.UPGRADING);
c1.transitionClusterVersion(stackId,v1,RepositoryVersionState.CURRENT);
clusters.mapHostToCluster("h-1",clusterName);
clusters.mapHostToCluster("h-2",clusterName);
clusters.mapHostToCluster("h-3",clusterName);
ClusterVersionDAOMock.failOnCurrentVersionState=false;
Service service=c1.addService("ZOOKEEPER");
ServiceComponent sc=service.addServiceComponent("ZOOKEEPER_SERVER");
sc.addServiceComponentHost("h-1");
sc.addServiceComponentHost("h-2");
service=c1.addService("SQOOP");
sc=service.addServiceComponent("SQOOP");
sc.addServiceComponentHost("h-3");
List entities=hostVersionDAO.findByClusterAndHost(clusterName,"h-3");
assertTrue("Expected no host versions",null == entities || 0 == entities.size());
c1.createClusterVersion(stackId,v2,"admin",RepositoryVersionState.INSTALLING);
c1.transitionClusterVersion(stackId,v2,RepositoryVersionState.INSTALLED);
c1.transitionClusterVersion(stackId,v2,RepositoryVersionState.UPGRADING);
c1.transitionClusterVersion(stackId,v2,RepositoryVersionState.UPGRADED);
c1.transitionClusterVersion(stackId,v2,RepositoryVersionState.CURRENT);
entities=hostVersionDAO.findByClusterAndHost(clusterName,"h-3");
assertEquals(1,entities.size());
}
UtilityVerifier InternalCallVerifier NullVerifier HybridVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier mounts=new ArrayList();
mounts.add(new DiskInfo("/dev/sda","/mnt/disk1","5000000","4000000","10%","size","fstype"));
hostInfo.setMounts(mounts);
AgentEnv agentEnv=new AgentEnv();
Directory dir1=new Directory();
dir1.setName("/etc/hadoop");
dir1.setType("not_exist");
Directory dir2=new Directory();
dir2.setName("/var/log/hadoop");
dir2.setType("not_exist");
agentEnv.setStackFoldersAndFiles(new Directory[]{dir1,dir2});
AgentVersion agentVersion=new AgentVersion("0.0.x");
long currentTime=1001;
clusters.getHost("h1").handleEvent(new HostRegistrationRequestEvent("h1",agentVersion,currentTime,hostInfo,agentEnv));
Assert.assertEquals(HostState.WAITING_FOR_HOST_STATUS_UPDATES,clusters.getHost("h1").getState());
clusters.getHost("h1").setState(HostState.HEARTBEAT_LOST);
try {
clusters.getHost("h1").handleEvent(new HostHealthyHeartbeatEvent("h1",currentTime,null,null));
fail("Exception should be thrown on invalid event");
}
catch ( InvalidStateTransitionException e) {
}
}
BranchVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("a","b");
}
}
,new HashMap>());
config1.setTag("version1");
Config config2=configFactory.createNew(c1,"core-site",new HashMap(){
{
put("x","y");
}
}
,new HashMap>());
config2.setTag("version2");
config1.persist();
c1.addConfig(config1);
config2.persist();
c1.addConfig(config2);
Set configs=new HashSet();
configs.add(config1);
configs.add(config2);
c1.addDesiredConfig("admin",configs);
List serviceConfigVersions=c1.getServiceConfigVersions();
Assert.assertNotNull(serviceConfigVersions);
Assert.assertEquals(1,serviceConfigVersions.size());
Assert.assertEquals(Long.valueOf(1),serviceConfigVersions.get(0).getVersion());
Assert.assertEquals(2,c1.getDesiredConfigs().size());
Assert.assertEquals("version1",c1.getDesiredConfigByType("hdfs-site").getTag());
Assert.assertEquals("version2",c1.getDesiredConfigByType("core-site").getTag());
Map> activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals(1,activeServiceConfigVersions.size());
c1.deleteService("HDFS");
Assert.assertEquals(0,c1.getServices().size());
Assert.assertEquals(0,c1.getServiceConfigVersions().size());
EntityManager em=injector.getProvider(EntityManager.class).get();
Assert.assertEquals(0,em.createQuery("SELECT serviceConfig from ServiceConfigEntity serviceConfig").getResultList().size());
Assert.assertEquals(2,em.createQuery("SELECT config from ClusterConfigEntity config").getResultList().size());
List configMappingEntities=em.createQuery("SELECT configmapping from ClusterConfigMappingEntity configmapping",ClusterConfigMappingEntity.class).getResultList();
Assert.assertEquals(2,configMappingEntities.size());
for ( ClusterConfigMappingEntity configMappingEntity : configMappingEntities) {
if (StringUtils.equals(configMappingEntity.getType(),"core-site")) {
assertEquals("core-site is not part of HDFS in test stack, should remain mapped to cluster",1,configMappingEntity.isSelected());
}
if (StringUtils.equals(configMappingEntity.getType(),"hdfs-site")) {
assertEquals("hdfs-site should be unmapped from cluster when HDFS service is removed",0,configMappingEntity.isSelected());
}
}
Assert.assertEquals(0,em.createNativeQuery("SELECT * from serviceconfigmapping").getResultList().size());
}
UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier scHosts;
scHosts=c1.getServiceComponentHosts("HDFS",null);
Assert.assertEquals(3,scHosts.size());
scHosts=c1.getServiceComponentHosts("UNKNOWN SERVICE",null);
Assert.assertEquals(0,scHosts.size());
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("a","b");
}
}
,new HashMap>());
config1.setTag("version1");
Config config2=configFactory.createNew(c1,"global",new HashMap(){
{
put("x","y");
}
}
,new HashMap>());
config2.setTag("version2");
Config config3=configFactory.createNew(c1,"core-site",new HashMap(){
{
put("x","y");
}
}
,new HashMap>());
config3.setTag("version2");
c1.addConfig(config1);
c1.addConfig(config2);
c1.addConfig(config3);
try {
c1.addDesiredConfig(null,Collections.singleton(config1));
fail("Cannot set a null user with config");
}
catch ( Exception e) {
}
c1.addDesiredConfig("_test1",Collections.singleton(config1));
c1.addDesiredConfig("_test3",Collections.singleton(config3));
Map desiredConfigs=c1.getDesiredConfigs();
Assert.assertFalse("Expect desired config not contain 'mapred-site'",desiredConfigs.containsKey("mapred-site"));
Assert.assertTrue("Expect desired config contain " + config1.getType(),desiredConfigs.containsKey("global"));
Assert.assertTrue("Expect desired config contain " + config3.getType(),desiredConfigs.containsKey("core-site"));
Assert.assertEquals("Expect desired config for global should be " + config1.getTag(),config1.getTag(),desiredConfigs.get(config1.getType()).getTag());
Assert.assertEquals("_test1",desiredConfigs.get(config1.getType()).getUser());
Assert.assertEquals("_test3",desiredConfigs.get(config3.getType()).getUser());
DesiredConfig dc=desiredConfigs.get(config1.getType());
Assert.assertTrue("Expect no host-level overrides",(null == dc.getHostOverrides() || dc.getHostOverrides().size() == 0));
c1.addDesiredConfig("_test2",Collections.singleton(config2));
Assert.assertEquals("_test2",c1.getDesiredConfigs().get(config2.getType()).getUser());
c1.addDesiredConfig("_test1",Collections.singleton(config1));
Host host=clusters.getHost("h1");
host.addDesiredConfig(c1.getClusterId(),true,"_test2",config2);
desiredConfigs=c1.getDesiredConfigs();
dc=desiredConfigs.get(config1.getType());
Assert.assertNotNull("Expect host-level overrides",dc.getHostOverrides());
Assert.assertEquals("Expect one host-level override",1,dc.getHostOverrides().size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier (){
{
put("a","b");
}
}
,new HashMap>());
config1.setTag("version1");
c1.addConfig(config1);
ServiceConfigVersionResponse scvResponse=c1.addDesiredConfig("admin",Collections.singleton(config1));
assertEquals("SCV 1 should be created",Long.valueOf(1),scvResponse.getVersion());
Map> activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals("Only one scv should be active",1,activeServiceConfigVersions.get("HDFS").size());
Config config2=configFactory.createNew(c1,"hdfs-site",new HashMap(){
{
put("a","c");
}
}
,new HashMap>());
config2.setTag("version2");
ConfigGroup configGroup=configGroupFactory.createNew(c1,"test group","HDFS","descr",Collections.singletonMap("hdfs-site",config2),Collections.emptyMap());
configGroup.persist();
c1.addConfigGroup(configGroup);
scvResponse=c1.createServiceConfigVersion("HDFS","admin","test note",configGroup);
assertEquals("SCV 2 should be created",Long.valueOf(2),scvResponse.getVersion());
activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals("Two service config versions should be active, for default and test groups",2,activeServiceConfigVersions.get("HDFS").size());
Config config3=configFactory.createNew(c1,"hdfs-site",new HashMap(){
{
put("a","d");
}
}
,new HashMap>());
configGroup.setConfigurations(Collections.singletonMap("hdfs-site",config3));
configGroup.persist();
scvResponse=c1.createServiceConfigVersion("HDFS","admin","test note",configGroup);
assertEquals("SCV 3 should be created",Long.valueOf(3),scvResponse.getVersion());
activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals("Two service config versions should be active, for default and test groups",2,activeServiceConfigVersions.get("HDFS").size());
assertEquals(3,c1.getServiceConfigVersions().size());
scvResponse=c1.setServiceConfigVersion("HDFS",2L,"admin","group rollback");
assertEquals("SCV 4 should be created",Long.valueOf(4),scvResponse.getVersion());
configGroup=c1.getConfigGroups().get(configGroup.getId());
activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals("Two service config versions should be active, for default and test groups",2,activeServiceConfigVersions.get("HDFS").size());
assertEquals(4,c1.getServiceConfigVersions().size());
Map configProperties=configGroup.getConfigurations().get("hdfs-site").getProperties();
assertEquals("Configurations should be rolled back to a:c ","c",configProperties.get("a"));
Config config4=new ConfigImpl("hdfs-site");
config4.setProperties(new HashMap(){
{
put("a","b");
}
}
);
ConfigGroup configGroup2=configGroupFactory.createNew(c1,"test group 2","HDFS","descr",Collections.singletonMap("hdfs-site",config4),Collections.emptyMap());
configGroup2.persist();
c1.addConfigGroup(configGroup2);
scvResponse=c1.createServiceConfigVersion("HDFS","admin","test note",configGroup2);
assertEquals("SCV 5 should be created",Long.valueOf(5),scvResponse.getVersion());
activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals("Three service config versions should be active, for default and test groups",3,activeServiceConfigVersions.get("HDFS").size());
assertEquals("Five total scvs",5,c1.getServiceConfigVersions().size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (){
{
put("one","two");
}
}
,new HashMap>());
originalConfig.setTag("version3");
originalConfig.persist();
cluster.addConfig(originalConfig);
ConfigGroup configGroup=configGroupFactory.createNew(cluster,"g1","t1","",new HashMap(){
{
put("foo-site",originalConfig);
}
}
,Collections.emptyMap());
configGroup.persist();
cluster.addConfigGroup(configGroup);
clusterEntity=clusterDAO.findByName("c1");
assertEquals(1,clusterEntity.getClusterConfigEntities().size());
Map configsByType=cluster.getConfigsByType("foo-site");
Config config=configsByType.entrySet().iterator().next().getValue();
Map properties=config.getProperties();
properties.put("three","four");
config.setProperties(properties);
config.persist(false);
clusterEntity=clusterDAO.findByName("c1");
assertEquals(1,clusterEntity.getClusterConfigEntities().size());
ClusterConfigEntity clusterConfigEntity=clusterEntity.getClusterConfigEntities().iterator().next();
assertTrue(clusterConfigEntity.getData().contains("one"));
assertTrue(clusterConfigEntity.getData().contains("two"));
assertTrue(clusterConfigEntity.getData().contains("three"));
assertTrue(clusterConfigEntity.getData().contains("four"));
cluster.refresh();
clusterEntity=clusterDAO.findByName("c1");
assertEquals(1,clusterEntity.getClusterConfigEntities().size());
clusterConfigEntity=clusterEntity.getClusterConfigEntities().iterator().next();
assertTrue(clusterConfigEntity.getData().contains("one"));
assertTrue(clusterConfigEntity.getData().contains("two"));
assertTrue(clusterConfigEntity.getData().contains("three"));
assertTrue(clusterConfigEntity.getData().contains("four"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > propAttributes=new HashMap>();
propAttributes.put("final",new HashMap());
propAttributes.get("final").put("test","true");
Config config=configFactory.createNew(c1,"hdfs-site",new HashMap(){
{
put("test","test");
}
}
,propAttributes);
config.setTag("1");
host1.addDesiredConfig(c1.getClusterId(),true,"test",config);
Map> configs=c1.getAllHostsDesiredConfigs();
assertTrue(configs.containsKey(hostEntity1.getHostId()));
assertEquals(1,configs.get(hostEntity1.getHostId()).size());
List hostIds=new ArrayList();
hostIds.add(hostEntity1.getHostId());
configs=c1.getHostsDesiredConfigs(hostIds);
assertTrue(configs.containsKey(hostEntity1.getHostId()));
assertEquals(1,configs.get(hostEntity1.getHostId()).size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier clusterConfigs=clusterDAO.getAllConfigurations(cluster.getClusterId(),newStackId);
Assert.assertEquals(1,clusterConfigs.size());
cluster.removeConfigurations(newStackId);
clusterConfigs=clusterDAO.getAllConfigurations(cluster.getClusterId(),newStackId);
Assert.assertEquals(0,clusterConfigs.size());
}
InternalCallVerifier EqualityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier hostVersionsH1Before=hostVersionDAO.findByClusterAndHost("c1","h1");
assertEquals(1,hostVersionsH1Before.size());
c1.transitionHostsToInstalling(entityHDP2);
List hostVersionsH1After=hostVersionDAO.findByClusterAndHost("c1","h1");
assertEquals(2,hostVersionsH1After.size());
boolean checked=false;
for ( HostVersionEntity entity : hostVersionsH1After) {
StackEntity repoVersionStackEntity=entity.getRepositoryVersion().getStack();
if (repoVersionStackEntity.getStackName().equals("HDP") && repoVersionStackEntity.getStackVersion().equals("0.2")) {
assertEquals(RepositoryVersionState.INSTALLING,entity.getState());
checked=true;
break;
}
}
assertTrue(checked);
c1.transitionHostsToInstalling(entityHDP2);
hostVersionsH1After=hostVersionDAO.findByClusterAndHost("c1","h1");
assertEquals(2,hostVersionsH1After.size());
checked=false;
for ( HostVersionEntity entity : hostVersionsH1After) {
StackEntity repoVersionStackEntity=entity.getRepositoryVersion().getStack();
if (repoVersionStackEntity.getStackName().equals("HDP") && repoVersionStackEntity.getStackVersion().equals("0.2")) {
assertEquals(RepositoryVersionState.INSTALLING,entity.getState());
checked=true;
break;
}
}
assertTrue(checked);
List hostVersionEntities=hostVersionDAO.findAll();
for ( HostVersionEntity hostVersionEntity : hostVersionEntities) {
hostVersionEntity.setState(RepositoryVersionState.INSTALL_FAILED);
hostVersionDAO.merge(hostVersionEntity);
}
hostVersionEntities=hostVersionDAO.findAll();
for ( HostVersionEntity hostVersionEntity : hostVersionEntities) {
assertEquals(RepositoryVersionState.INSTALL_FAILED,hostVersionEntity.getState());
}
Collection hosts=c1.getHosts();
Iterator iterator=hosts.iterator();
Host hostInMaintenanceMode=iterator.next();
Host hostNotInMaintenanceMode=iterator.next();
hostInMaintenanceMode.setMaintenanceState(c1.getClusterId(),MaintenanceState.ON);
c1.transitionHostsToInstalling(entityHDP2);
List hostInMaintModeVersions=hostVersionDAO.findByClusterAndHost("c1",hostInMaintenanceMode.getHostName());
List otherHostVersions=hostVersionDAO.findByClusterAndHost("c1",hostNotInMaintenanceMode.getHostName());
for ( HostVersionEntity hostVersionEntity : hostInMaintModeVersions) {
StackEntity repoVersionStackEntity=hostVersionEntity.getRepositoryVersion().getStack();
if (repoVersionStackEntity.getStackName().equals("HDP") && repoVersionStackEntity.getStackVersion().equals("0.2")) {
assertEquals(RepositoryVersionState.OUT_OF_SYNC,hostVersionEntity.getState());
}
}
for ( HostVersionEntity hostVersionEntity : otherHostVersions) {
StackEntity repoVersionStackEntity=hostVersionEntity.getRepositoryVersion().getStack();
if (repoVersionStackEntity.getStackName().equals("HDP") && repoVersionStackEntity.getStackVersion().equals("0.2")) {
assertEquals(RepositoryVersionState.INSTALLING,hostVersionEntity.getState());
}
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("a","b");
}
}
,new HashMap>());
config1.setTag("version1");
Config config2=configFactory.createNew(c1,"hdfs-site",new HashMap(){
{
put("x","y");
}
}
,new HashMap>());
config2.setTag("version2");
c1.addConfig(config1);
c1.addConfig(config2);
c1.addDesiredConfig("admin",Collections.singleton(config1));
List serviceConfigVersions=c1.getServiceConfigVersions();
Assert.assertNotNull(serviceConfigVersions);
Assert.assertEquals(1,serviceConfigVersions.size());
Map> activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals(1,activeServiceConfigVersions.size());
ServiceConfigVersionResponse hdfsResponse=activeServiceConfigVersions.get("HDFS").iterator().next();
Assert.assertEquals("HDFS",hdfsResponse.getServiceName());
Assert.assertEquals("c1",hdfsResponse.getClusterName());
Assert.assertEquals("admin",hdfsResponse.getUserName());
Assert.assertEquals("default",hdfsResponse.getGroupName());
Assert.assertEquals(Long.valueOf(-1),hdfsResponse.getGroupId());
Assert.assertEquals(Long.valueOf(1),hdfsResponse.getVersion());
c1.addDesiredConfig("admin",Collections.singleton(config2));
serviceConfigVersions=c1.getServiceConfigVersions();
Assert.assertNotNull(serviceConfigVersions);
Assert.assertEquals(2,serviceConfigVersions.size());
activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals(1,activeServiceConfigVersions.size());
hdfsResponse=activeServiceConfigVersions.get("HDFS").iterator().next();
Assert.assertEquals("HDFS",hdfsResponse.getServiceName());
Assert.assertEquals("c1",hdfsResponse.getClusterName());
Assert.assertEquals("admin",hdfsResponse.getUserName());
assertEquals(Long.valueOf(2),hdfsResponse.getVersion());
c1.setServiceConfigVersion("HDFS",1L,"admin","test_note");
serviceConfigVersions=c1.getServiceConfigVersions();
Assert.assertNotNull(serviceConfigVersions);
Assert.assertEquals(3,serviceConfigVersions.size());
activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals(1,activeServiceConfigVersions.size());
hdfsResponse=activeServiceConfigVersions.get("HDFS").iterator().next();
Assert.assertEquals("HDFS",hdfsResponse.getServiceName());
Assert.assertEquals("c1",hdfsResponse.getClusterName());
Assert.assertEquals("admin",hdfsResponse.getUserName());
assertEquals(Long.valueOf(3),hdfsResponse.getVersion());
}
BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier clusterConfigMappings=clusterEntity.getConfigMappingEntities();
Assert.assertEquals(2,clusterConfigMappings.size());
for ( ClusterConfigMappingEntity clusterConfigMapping : clusterConfigMappings) {
if (clusterConfigMapping.getTag().equals("version-1")) {
Assert.assertEquals(1,clusterConfigMapping.isSelected());
}
else {
Assert.assertEquals(0,clusterConfigMapping.isSelected());
}
}
cluster.applyLatestConfigurations(newStackId);
clusterEntity=clusterDAO.findByName("c1");
clusterConfigMappings=clusterEntity.getConfigMappingEntities();
Assert.assertEquals(2,clusterConfigMappings.size());
for ( ClusterConfigMappingEntity clusterConfigMapping : clusterConfigMappings) {
if (clusterConfigMapping.getTag().equals("version-1")) {
Assert.assertEquals(0,clusterConfigMapping.isSelected());
}
else {
Assert.assertEquals(1,clusterConfigMapping.isSelected());
}
}
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier IgnoredMethod HybridVerifier services=cluster.getServices();
Assert.assertNotNull(services.get("HDFS"));
}
APIUtilityVerifier IterativeVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","5.9");
Cluster cluster=createClusterForRU(clusterName,stackId,hostAttributes);
Host deadHost=cluster.getHosts().iterator().next();
deadHost.setState(HostState.UNHEALTHY);
int versionedComponentCount=0;
List hostComponentStates=hostComponentStateDAO.findAll();
for (int i=0; i < hostComponentStates.size(); i++) {
HostComponentStateEntity hce=hostComponentStates.get(i);
ComponentInfo compInfo=metaInfo.getComponent(stackId.getStackName(),stackId.getStackVersion(),hce.getServiceName(),hce.getComponentName());
if (hce.getHostName().equals(deadHost.getHostName())) {
continue;
}
if (compInfo.isVersionAdvertised()) {
hce.setVersion(v1);
hostComponentStateDAO.merge(hce);
versionedComponentCount++;
}
Service svc=cluster.getService(hce.getServiceName());
ServiceComponent svcComp=svc.getServiceComponent(hce.getComponentName());
ServiceComponentHost scHost=svcComp.getServiceComponentHost(hce.getHostName());
scHost.recalculateHostVersionState();
cluster.recalculateClusterVersionState(rv1);
Collection clusterVersions=cluster.getAllClusterVersions();
if (versionedComponentCount > 0) {
RepositoryVersionEntity repositoryVersion=repositoryVersionDAO.findByStackAndVersion(stackId,v1);
Assert.assertNotNull(repositoryVersion);
Assert.assertTrue(clusterVersions != null && clusterVersions.size() == 1);
if (versionedComponentCount == 1 && i < (hostComponentStates.size() - 1)) {
Assert.assertEquals(clusterVersions.iterator().next().getState(),RepositoryVersionState.CURRENT);
}
}
}
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("a","b");
}
}
,new HashMap>());
config1.setTag("version1");
Config config2=configFactory.createNew(c1,"core-site",new HashMap(){
{
put("x","y");
}
}
,new HashMap>());
config2.setTag("version2");
c1.addConfig(config1);
c1.addConfig(config2);
Set configs=new HashSet();
configs.add(config1);
configs.add(config2);
c1.addDesiredConfig("admin",configs);
List serviceConfigVersions=c1.getServiceConfigVersions();
Assert.assertNotNull(serviceConfigVersions);
Assert.assertEquals(1,serviceConfigVersions.size());
Assert.assertEquals(Long.valueOf(1),serviceConfigVersions.get(0).getVersion());
Assert.assertEquals(2,c1.getDesiredConfigs().size());
Assert.assertEquals("version1",c1.getDesiredConfigByType("hdfs-site").getTag());
Assert.assertEquals("version2",c1.getDesiredConfigByType("core-site").getTag());
Map> activeServiceConfigVersions=c1.getActiveServiceConfigVersions();
Assert.assertEquals(1,activeServiceConfigVersions.size());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier scHosts=c1.getServiceComponentHosts("h1");
Assert.assertEquals(1,scHosts.size());
Iterator iterator=scHosts.iterator();
try {
while (iterator.hasNext()) {
iterator.next();
Service s1=serviceFactory.createNew(c1,"PIG");
c1.addService(s1);
s1.persist();
ServiceComponent sc1=serviceComponentFactory.createNew(s1,"PIG");
s1.addServiceComponent(sc1);
sc1.persist();
ServiceComponentHost sch1=serviceComponentHostFactory.createNew(sc1,"h1");
sc1.addServiceComponentHost(sch1);
sch1.persist();
}
}
catch ( ConcurrentModificationException e) {
Assert.assertTrue("Failed to work concurrently with sch",false);
}
scHosts=c1.getServiceComponentHosts("h1");
Assert.assertEquals(2,scHosts.size());
}
InternalCallVerifier EqualityVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","5.9");
h.setHostAttributes(hostAttributes);
h.persist();
}
String v1="2.0.5-1";
String v2="2.0.5-2";
c1.setDesiredStackVersion(stackId);
RepositoryVersionEntity rve1=helper.getOrCreateRepositoryVersion(stackId,v1);
RepositoryVersionEntity rve2=helper.getOrCreateRepositoryVersion(stackId,v2);
c1.setCurrentStackVersion(stackId);
c1.createClusterVersion(stackId,v1,"admin",RepositoryVersionState.UPGRADING);
c1.transitionClusterVersion(stackId,v1,RepositoryVersionState.CURRENT);
clusters.mapHostToCluster("h-1",clusterName);
clusters.mapHostToCluster("h-2",clusterName);
ClusterVersionDAOMock.failOnCurrentVersionState=false;
Service service=c1.addService("ZOOKEEPER");
ServiceComponent sc=service.addServiceComponent("ZOOKEEPER_SERVER");
sc.addServiceComponentHost("h-1");
sc.addServiceComponentHost("h-2");
c1.createClusterVersion(stackId,v2,"admin",RepositoryVersionState.INSTALLING);
c1.transitionClusterVersion(stackId,v2,RepositoryVersionState.INSTALLED);
c1.transitionClusterVersion(stackId,v2,RepositoryVersionState.OUT_OF_SYNC);
clusters.mapHostToCluster(h3,clusterName);
HostEntity hostEntity3=mock(HostEntity.class);
when(hostEntity3.getHostName()).thenReturn(h3);
HostVersionDAO hostVersionDAOMock=mock(HostVersionDAO.class);
Field field=ClusterImpl.class.getDeclaredField("hostVersionDAO");
field.setAccessible(true);
field.set(c1,hostVersionDAOMock);
ArgumentCaptor hostVersionCaptor=ArgumentCaptor.forClass(HostVersionEntity.class);
ClusterVersionDAOMock.mockedClusterVersions=new ArrayList(){
{
addAll(c1.getAllClusterVersions());
}
}
;
c1.transitionHostVersionState(hostEntity3,rve1,stackId);
ClusterVersionDAOMock.mockedClusterVersions=null;
verify(hostVersionDAOMock).merge(hostVersionCaptor.capture());
assertEquals(hostVersionCaptor.getValue().getState(),RepositoryVersionState.CURRENT);
}
APIUtilityVerifier IterativeVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","5.9");
Cluster cluster=createClusterForRU(clusterName,stackId,hostAttributes);
int versionedComponentCount=0;
List hostComponentStates=hostComponentStateDAO.findAll();
for (int i=0; i < hostComponentStates.size(); i++) {
HostComponentStateEntity hce=hostComponentStates.get(i);
ComponentInfo compInfo=metaInfo.getComponent(stackId.getStackName(),stackId.getStackVersion(),hce.getServiceName(),hce.getComponentName());
if (compInfo.isVersionAdvertised()) {
hce.setVersion(v1);
hostComponentStateDAO.merge(hce);
versionedComponentCount++;
}
Service svc=cluster.getService(hce.getServiceName());
ServiceComponent svcComp=svc.getServiceComponent(hce.getComponentName());
ServiceComponentHost scHost=svcComp.getServiceComponentHost(hce.getHostName());
scHost.recalculateHostVersionState();
cluster.recalculateClusterVersionState(rv1);
Collection clusterVersions=cluster.getAllClusterVersions();
if (versionedComponentCount > 0) {
RepositoryVersionEntity repositoryVersion=repositoryVersionDAO.findByStackAndVersion(stackId,v1);
Assert.assertNotNull(repositoryVersion);
Assert.assertTrue(clusterVersions != null && clusterVersions.size() == 1);
if (versionedComponentCount == 1 && i < (hostComponentStates.size() - 1)) {
Assert.assertEquals(clusterVersions.iterator().next().getState(),RepositoryVersionState.UPGRADING);
}
if (i == hostComponentStates.size() - 1) {
Assert.assertEquals(clusterVersions.iterator().next().getState(),RepositoryVersionState.CURRENT);
}
}
}
addHost("h-4",hostAttributes);
clusters.mapHostToCluster("h-4",clusterName);
Service svc2=cluster.getService("ZOOKEEPER");
Service svc3=cluster.getService("GANGLIA");
ServiceComponent sc2CompA=svc2.getServiceComponent("ZOOKEEPER_SERVER");
ServiceComponent sc2CompB=svc2.getServiceComponent("ZOOKEEPER_CLIENT");
ServiceComponent sc3CompB=svc3.getServiceComponent("GANGLIA_MONITOR");
ServiceComponentHost schHost4Serv2CompA=serviceComponentHostFactory.createNew(sc2CompA,"h-4");
ServiceComponentHost schHost4Serv2CompB=serviceComponentHostFactory.createNew(sc2CompB,"h-4");
ServiceComponentHost schHost4Serv3CompB=serviceComponentHostFactory.createNew(sc3CompB,"h-4");
sc2CompA.addServiceComponentHost(schHost4Serv2CompA);
sc2CompB.addServiceComponentHost(schHost4Serv2CompB);
sc3CompB.addServiceComponentHost(schHost4Serv3CompB);
schHost4Serv2CompA.persist();
schHost4Serv2CompB.persist();
schHost4Serv3CompB.persist();
simulateStackVersionListener(stackId,v1,cluster,hostComponentStateDAO.findByHost("h-4"));
Collection hostVersions=hostVersionDAO.findAll();
Assert.assertEquals(hostVersions.size(),clusters.getHosts().size());
HostVersionEntity h4Version1=hostVersionDAO.findByClusterStackVersionAndHost(clusterName,stackId,v1,"h-4");
Assert.assertNotNull(h4Version1);
Assert.assertEquals(h4Version1.getState(),RepositoryVersionState.CURRENT);
String v2="2.2.0-456";
RepositoryVersionEntity rv2=helper.getOrCreateRepositoryVersion(stackId,v2);
for ( String hostName : clusters.getHostsForCluster(clusterName).keySet()) {
HostEntity host=hostDAO.findByName(hostName);
HostVersionEntity hve=new HostVersionEntity(host,rv2,RepositoryVersionState.INSTALLED);
hostVersionDAO.create(hve);
}
cluster.createClusterVersion(stackId,v2,"admin",RepositoryVersionState.INSTALLING);
cluster.transitionClusterVersion(stackId,v2,RepositoryVersionState.INSTALLED);
ClusterVersionEntity cv2=clusterVersionDAO.findByClusterAndStackAndVersion(clusterName,stackId,v2);
Assert.assertNotNull(cv2);
Assert.assertEquals(cv2.getState(),RepositoryVersionState.INSTALLED);
addHost("h-5",hostAttributes);
clusters.mapHostToCluster("h-5",clusterName);
ServiceComponentHost schHost5Serv3CompB=serviceComponentHostFactory.createNew(sc3CompB,"h-5");
sc3CompB.addServiceComponentHost(schHost5Serv3CompB);
schHost5Serv3CompB.persist();
HostVersionEntity h5Version2=hostVersionDAO.findByClusterStackVersionAndHost(clusterName,stackId,v2,"h-5");
Assert.assertNotNull(h5Version2);
Assert.assertEquals(h5Version2.getState(),RepositoryVersionState.OUT_OF_SYNC);
h5Version2.setState(RepositoryVersionState.INSTALLED);
hostVersionDAO.merge(h5Version2);
versionedComponentCount=0;
hostComponentStates=hostComponentStateDAO.findAll();
for (int i=0; i < hostComponentStates.size(); i++) {
HostComponentStateEntity hce=hostComponentStates.get(i);
ComponentInfo compInfo=metaInfo.getComponent(stackId.getStackName(),stackId.getStackVersion(),hce.getServiceName(),hce.getComponentName());
if (compInfo.isVersionAdvertised()) {
hce.setVersion(v2);
hostComponentStateDAO.merge(hce);
versionedComponentCount++;
}
Service svc=cluster.getService(hce.getServiceName());
ServiceComponent svcComp=svc.getServiceComponent(hce.getComponentName());
ServiceComponentHost scHost=svcComp.getServiceComponentHost(hce.getHostName());
scHost.recalculateHostVersionState();
cluster.recalculateClusterVersionState(rv2);
Collection clusterVersions=cluster.getAllClusterVersions();
if (versionedComponentCount > 0) {
RepositoryVersionEntity repositoryVersion=repositoryVersionDAO.findByStackAndVersion(stackId,v2);
Assert.assertNotNull(repositoryVersion);
Assert.assertTrue(clusterVersions != null && clusterVersions.size() == 2);
if (versionedComponentCount == 1 && i < (hostComponentStates.size() - 1)) {
cv2=clusterVersionDAO.findByClusterAndStackAndVersion(clusterName,stackId,v2);
Assert.assertEquals(cv2.getState(),RepositoryVersionState.UPGRADING);
}
}
}
cv2=clusterVersionDAO.findByClusterAndStackAndVersion(clusterName,stackId,v2);
Assert.assertEquals(cv2.getState(),RepositoryVersionState.UPGRADING);
Collection v2HostVersions=hostVersionDAO.findByClusterStackAndVersion(clusterName,stackId,v2);
Assert.assertEquals(v2HostVersions.size(),clusters.getHostsForCluster(clusterName).size());
for ( HostVersionEntity hve : v2HostVersions) {
if (hve.getHostName().equals("h-3") || hve.getHostName().equals("h-5")) {
Assert.assertEquals(hve.getState(),RepositoryVersionState.INSTALLED);
}
else {
Assert.assertEquals(hve.getState(),RepositoryVersionState.UPGRADED);
}
}
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > c1PropAttributes=new HashMap>();
c1PropAttributes.put("final",new HashMap());
c1PropAttributes.get("final").put("a","true");
Map> c2PropAttributes=new HashMap>();
c2PropAttributes.put("final",new HashMap());
c2PropAttributes.get("final").put("x","true");
Config config1=configFactory.createNew(c1,"global",new HashMap(){
{
put("a","b");
}
}
,c1PropAttributes);
config1.setTag("version1");
Config config2=configFactory.createNew(c1,"global",new HashMap(){
{
put("x","y");
}
}
,c2PropAttributes);
config2.setTag("version2");
Config config3=configFactory.createNew(c1,"core-site",new HashMap(){
{
put("x","y");
}
}
,new HashMap>());
config3.setTag("version2");
c1.addConfig(config1);
c1.addConfig(config2);
c1.addConfig(config3);
c1.addDesiredConfig("_test",Collections.singleton(config1));
Config res=c1.getDesiredConfigByType("global");
Assert.assertNotNull("Expected non-null config",res);
Assert.assertEquals("true",res.getPropertiesAttributes().get("final").get("a"));
res=c1.getDesiredConfigByType("core-site");
Assert.assertNull("Expected null config",res);
c1.addDesiredConfig("_test",Collections.singleton(config2));
res=c1.getDesiredConfigByType("global");
Assert.assertEquals("Expected version tag to be 'version2'","version2",res.getTag());
Assert.assertEquals("true",res.getPropertiesAttributes().get("final").get("x"));
}
UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier services=c1.getServices();
Assert.assertEquals(2,services.size());
Assert.assertTrue(services.containsKey("HDFS"));
Assert.assertTrue(services.containsKey("MAPREDUCE"));
}
InternalCallVerifier EqualityVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","5.9");
host.setHostAttributes(hostAttributes);
host.setState(HostState.HEALTHY);
host.setHealthStatus(new HostHealthStatus(HostHealthStatus.HealthStatus.HEALTHY,""));
host.setStatus(host.getHealthStatus().getHealthStatus().name());
host.persist();
c1.setDesiredStackVersion(new StackId("HDP-2.0.6"));
clusters.mapHostToCluster("h3","c1");
r=c1.convertToResponse();
Assert.assertEquals(Integer.valueOf(3),r.getTotalHosts());
Assert.assertEquals(0,r.getClusterHealthReport().getAlertStatusHosts());
Assert.assertEquals(1,r.getClusterHealthReport().getHealthyStatusHosts());
Assert.assertEquals(0,r.getClusterHealthReport().getUnhealthyStatusHosts());
Assert.assertEquals(2,r.getClusterHealthReport().getUnknownStatusHosts());
Assert.assertEquals(0,r.getClusterHealthReport().getStaleConfigsHosts());
Assert.assertEquals(0,r.getClusterHealthReport().getMaintenanceStateHosts());
Assert.assertEquals(1,r.getClusterHealthReport().getHealthyStateHosts());
Assert.assertEquals(0,r.getClusterHealthReport().getHeartbeatLostStateHosts());
Assert.assertEquals(2,r.getClusterHealthReport().getInitStateHosts());
Assert.assertEquals(0,r.getClusterHealthReport().getUnhealthyStateHosts());
StringBuilder sb=new StringBuilder();
c1.debugDump(sb);
}
Class: org.apache.ambari.server.state.cluster.ClustersImplTest InternalCallVerifier EqualityVerifier attributes=new HashMap();
attributes.put("foo","bar");
Cluster cluster=createMock(Cluster.class);
ClustersImpl clusters=createMockBuilder(ClustersImpl.class).addMockedMethod("findCluster",String.class).createMock();
expect(clusters.findCluster("c1")).andReturn(cluster);
expect(cluster.getSessionAttributes()).andReturn(attributes);
replay(clusters,cluster);
assertEquals(attributes,clusters.getSessionAttributes("c1"));
verify(clusters,cluster);
}
Class: org.apache.ambari.server.state.cluster.ClustersTest UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier c=clusters.getClustersForHost(h3);
Assert.assertEquals(0,c.size());
clusters.mapHostToCluster(h1,c1);
clusters.mapHostToCluster(h2,c1);
try {
clusters.mapHostToCluster(h1,c1);
fail("Expected exception for duplicate");
}
catch ( DuplicateResourceException e) {
}
Cluster c3=(Cluster)clusters.getClustersForHost(h1).toArray()[0];
Cluster c4=(Cluster)clusters.getClustersForHost(h2).toArray()[0];
Assert.assertEquals(c3,c4);
Set hostnames=new HashSet();
hostnames.add(h1);
hostnames.add(h2);
clusters.mapHostsToCluster(hostnames,c2);
c=clusters.getClustersForHost(h1);
Assert.assertEquals(2,c.size());
c=clusters.getClustersForHost(h2);
Assert.assertEquals(2,c.size());
Map hostsForC1=clusters.getHostsForCluster(c1);
Assert.assertEquals(2,hostsForC1.size());
Assert.assertTrue(hostsForC1.containsKey(h1));
Assert.assertTrue(hostsForC1.containsKey(h2));
Assert.assertNotNull(hostsForC1.get(h1));
Assert.assertNotNull(hostsForC1.get(h2));
}
UtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hosts=clusters.getHosts();
Assert.assertEquals(3,hosts.size());
Assert.assertNotNull(clusters.getHost(h1));
Assert.assertNotNull(clusters.getHost(h2));
Assert.assertNotNull(clusters.getHost(h3));
Host h=clusters.getHost(h2);
Assert.assertNotNull(h);
try {
clusters.getHost("foo");
fail("Expected error for unknown host");
}
catch ( HostNotFoundException e) {
}
}
UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier verifyClusters=clusters.getClusters();
Assert.assertTrue(verifyClusters.containsKey(c1));
Assert.assertTrue(verifyClusters.containsKey(c2));
Assert.assertNotNull(verifyClusters.get(c1));
Assert.assertNotNull(verifyClusters.get(c2));
Cluster c=clusters.getCluster(c1);
c.setClusterName("foobar");
long cId=c.getClusterId();
Cluster changed=clusters.getCluster("foobar");
Assert.assertNotNull(changed);
Assert.assertEquals(cId,changed.getClusterId());
Assert.assertEquals("foobar",clusters.getClusterById(cId).getClusterName());
}
InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier (){
{
put("prop1","val1");
}
}
,new HashMap>());
config1.setTag("1");
config1.persist();
Config config2=injector.getInstance(ConfigFactory.class).createNew(cluster,"t1",new HashMap(){
{
put("prop2","val2");
}
}
,new HashMap>());
config2.setTag("2");
config2.persist();
cluster.addDesiredConfig("_test",Collections.singleton(config1));
clusters.addHost(h1);
clusters.addHost(h2);
Host host1=clusters.getHost(h1);
Host host2=clusters.getHost(h2);
setOsFamily(clusters.getHost(h1),"centos","5.9");
setOsFamily(clusters.getHost(h2),"centos","5.9");
host1.persist();
host2.persist();
clusters.mapHostsToCluster(new HashSet(){
{
addAll(Arrays.asList(h1,h2));
}
}
,c1);
host1.addDesiredConfig(cluster.getClusterId(),true,"_test",config2);
host1.persist();
Service hdfs=cluster.addService("HDFS");
hdfs.persist();
Assert.assertNotNull(injector.getInstance(ClusterServiceDAO.class).findByClusterAndServiceNames(c1,"HDFS"));
ServiceComponent nameNode=hdfs.addServiceComponent("NAMENODE");
nameNode.persist();
ServiceComponent dataNode=hdfs.addServiceComponent("DATANODE");
dataNode.persist();
ServiceComponent serviceCheckNode=hdfs.addServiceComponent("HDFS_CLIENT");
serviceCheckNode.persist();
ServiceComponentHost nameNodeHost=nameNode.addServiceComponentHost(h1);
nameNodeHost.persist();
HostEntity nameNodeHostEntity=hostDAO.findByName(nameNodeHost.getHostName());
Assert.assertNotNull(nameNodeHostEntity);
ServiceComponentHost dataNodeHost=dataNode.addServiceComponentHost(h2);
dataNodeHost.persist();
ServiceComponentHost serviceCheckNodeHost=serviceCheckNode.addServiceComponentHost(h2);
serviceCheckNodeHost.persist();
serviceCheckNodeHost.setState(State.UNKNOWN);
HostComponentDesiredStateEntityPK hkdspk=new HostComponentDesiredStateEntityPK();
hkdspk.setClusterId(nameNodeHost.getClusterId());
hkdspk.setHostId(nameNodeHostEntity.getHostId());
hkdspk.setServiceName(nameNodeHost.getServiceName());
hkdspk.setComponentName(nameNodeHost.getServiceComponentName());
Assert.assertNotNull(injector.getInstance(HostComponentStateDAO.class).findByIndex(nameNodeHost.getClusterId(),nameNodeHost.getServiceName(),nameNodeHost.getServiceComponentName(),nameNodeHostEntity.getHostId()));
Assert.assertNotNull(injector.getInstance(HostComponentDesiredStateDAO.class).findByPK(hkdspk));
Assert.assertEquals(2,injector.getProvider(EntityManager.class).get().createQuery("SELECT config FROM ClusterConfigEntity config").getResultList().size());
Assert.assertEquals(1,injector.getProvider(EntityManager.class).get().createQuery("SELECT state FROM ClusterStateEntity state").getResultList().size());
Assert.assertEquals(1,injector.getProvider(EntityManager.class).get().createQuery("SELECT config FROM ClusterConfigMappingEntity config").getResultList().size());
Blueprint bp=createNiceMock(Blueprint.class);
expect(bp.getName()).andReturn("TestBluePrint").anyTimes();
Configuration clusterConfig=new Configuration(Maps.>newHashMap(),Maps.>>newHashMap());
Map hostGroups=Maps.newHashMap();
TopologyRequest topologyRequest=createNiceMock(TopologyRequest.class);
expect(topologyRequest.getType()).andReturn(TopologyRequest.Type.PROVISION).anyTimes();
expect(topologyRequest.getBlueprint()).andReturn(bp).anyTimes();
expect(topologyRequest.getClusterId()).andReturn(cluster.getClusterId()).anyTimes();
expect(topologyRequest.getConfiguration()).andReturn(clusterConfig).anyTimes();
expect(topologyRequest.getDescription()).andReturn("Test description").anyTimes();
expect(topologyRequest.getHostGroupInfo()).andReturn(hostGroups).anyTimes();
replay(bp,topologyRequest);
persistedState.persistTopologyRequest(topologyRequest);
Assert.assertEquals(1,topologyRequestDAO.findByClusterId(cluster.getClusterId()).size());
clusters.deleteCluster(c1);
Assert.assertEquals(2,hostDAO.findAll().size());
Assert.assertNull(injector.getInstance(HostComponentStateDAO.class).findByIndex(nameNodeHost.getClusterId(),nameNodeHost.getServiceName(),nameNodeHost.getServiceComponentName(),nameNodeHostEntity.getHostId()));
Assert.assertNull(injector.getInstance(HostComponentDesiredStateDAO.class).findByPK(hkdspk));
Assert.assertEquals(0,injector.getProvider(EntityManager.class).get().createQuery("SELECT config FROM ClusterConfigEntity config").getResultList().size());
Assert.assertEquals(0,injector.getProvider(EntityManager.class).get().createQuery("SELECT state FROM ClusterStateEntity state").getResultList().size());
Assert.assertEquals(0,injector.getProvider(EntityManager.class).get().createQuery("SELECT config FROM ClusterConfigMappingEntity config").getResultList().size());
Assert.assertEquals(0,topologyRequestDAO.findByClusterId(cluster.getClusterId()).size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier UtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.state.cluster.ConcurrentServiceConfigVersionTest InternalCallVerifier EqualityVerifier threads=new ArrayList();
for (int i=0; i < NUMBER_OF_THREADS; i++) {
Thread thread=new ConcurrentServiceConfigThread(cluster);
threads.add(thread);
thread.start();
}
for ( Thread thread : threads) {
thread.join();
}
long maxVersion=NUMBER_OF_THREADS * NUMBER_OF_SERVICE_CONFIG_VERSIONS;
nextVersion=serviceConfigDAO.findNextServiceConfigVersion(cluster.getClusterId(),"HDFS");
Assert.assertEquals(maxVersion + 1,nextVersion);
}
Class: org.apache.ambari.server.state.cluster.ServiceComponentHostConcurrentWriteDeadlockTest BranchVerifier InternalCallVerifier BooleanVerifier serviceComponentHosts=new ArrayList();
serviceComponentHosts.add(nameNodeSCH);
serviceComponentHosts.add(dataNodeSCH);
List threads=new ArrayList();
for (int i=0; i < NUMBER_OF_THREADS; i++) {
ServiceComponentHostDeadlockWriter thread=new ServiceComponentHostDeadlockWriter();
thread.setServiceComponentHosts(serviceComponentHosts);
thread.start();
threads.add(thread);
}
DeadlockWarningThread wt=new DeadlockWarningThread(threads);
while (true) {
if (!wt.isAlive()) {
break;
}
}
if (wt.isDeadlocked()) {
Assert.assertFalse(wt.getErrorMessages().toString(),wt.isDeadlocked());
}
else {
Assert.assertFalse(wt.isDeadlocked());
}
}
Class: org.apache.ambari.server.state.host.HostImplTest InternalCallVerifier EqualityVerifier hostAttributes=host.getHostAttributes();
assertEquals("aaa",hostAttributes.get("foo"));
assertEquals("bbb",hostAttributes.get("bar"));
host=new HostImpl(hostEntity,true,injector);
hostAttributes=host.getHostAttributes();
assertEquals("aaa",hostAttributes.get("foo"));
assertEquals("bbb",hostAttributes.get("bar"));
verify(hostEntity,hostStateEntity,injector,hostDAO);
}
Class: org.apache.ambari.server.state.host.HostTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","6.3");
host.setHostAttributes(hostAttributes);
host.persist();
helper.getOrCreateRepositoryVersion(stackId,stackId.getStackVersion());
c1.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
c1.setDesiredStackVersion(stackId);
clusters.mapHostToCluster("h1","c1");
HostEntity entity=hostDAO.findByName("h1");
HostStateEntity stateEntity=entity.getHostStateEntity();
Assert.assertNull(stateEntity.getMaintenanceState());
Assert.assertEquals(MaintenanceState.OFF,host.getMaintenanceState(c1.getClusterId()));
host.setMaintenanceState(c1.getClusterId(),MaintenanceState.ON);
entity=hostDAO.findByName("h1");
stateEntity=entity.getHostStateEntity();
Assert.assertNotNull(stateEntity.getMaintenanceState());
Assert.assertEquals(MaintenanceState.ON,host.getMaintenanceState(c1.getClusterId()));
}
InternalCallVerifier EqualityVerifier mounts=new ArrayList();
mounts.add(new DiskInfo("/dev/sda","/mnt/disk1","5000000","4000000","10%","size","fstype"));
info.setMounts(mounts);
info.setHostName("foo");
info.setInterfaces("fip_4");
info.setArchitecture("os_arch");
info.setOS("os_type");
info.setMemoryTotal(10);
clusters.addHost("foo");
Host host=clusters.getHost("foo");
host.importHostInfo(info);
Assert.assertEquals(info.getHostName(),host.getHostName());
Assert.assertEquals(info.getFreeMemory(),host.getAvailableMemBytes());
Assert.assertEquals(info.getMemoryTotal(),host.getTotalMemBytes());
Assert.assertEquals(info.getProcessorCount(),host.getCpuCount());
Assert.assertEquals(info.getPhysicalProcessorCount(),host.getPhCpuCount());
Assert.assertEquals(info.getMounts().size(),host.getDisksInfo().size());
Assert.assertEquals(info.getArchitecture(),host.getOsArch());
Assert.assertEquals(info.getOS(),host.getOsType());
}
UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hostAttributes=new HashMap();
hostAttributes.put("os_family","redhat");
hostAttributes.put("os_release_version","6.3");
host.setHostAttributes(hostAttributes);
host.persist();
c1.setDesiredStackVersion(stackId);
clusters.mapHostToCluster("h1","c1");
ConfigFactory configFactory=injector.getInstance(ConfigFactory.class);
Config config=configFactory.createNew(c1,"global",new HashMap(){
{
put("a","b");
put("x","y");
}
}
,new HashMap>());
try {
host.addDesiredConfig(c1.getClusterId(),true,null,config);
Assert.fail("Expect failure when user is not specified.");
}
catch ( Exception e) {
}
config.setTag("v1");
host.addDesiredConfig(c1.getClusterId(),true,"_test",config);
Map map=host.getDesiredConfigs(c1.getClusterId());
Assert.assertTrue("Expect desired config to contain global",map.containsKey("global"));
Assert.assertEquals("Expect global user to be '_test'","_test",map.get("global").getUser());
config=configFactory.createNew(c1,"global",new HashMap(){
{
put("c","d");
}
}
,new HashMap>());
config.setTag("v2");
host.addDesiredConfig(c1.getClusterId(),true,"_test1",config);
map=host.getDesiredConfigs(c1.getClusterId());
Assert.assertTrue("Expect desired config to contain global",map.containsKey("global"));
Assert.assertEquals("Expect version to be 'v2'","v2",map.get("global").getTag());
Assert.assertEquals("Expect user to be '_test1'","_test1",map.get("global").getUser());
host.addDesiredConfig(c1.getClusterId(),false,"_test2",config);
map=host.getDesiredConfigs(c1.getClusterId());
Assert.assertEquals("Expect no mapping configs",0,map.size());
}
Class: org.apache.ambari.server.state.kerberos.KerberosConfigurationDescriptorTest BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > jsonData=new Gson().fromJson(JSON_MULTIPLE_VALUE,new TypeToken>>(){
}
.getType());
List configurations=new ArrayList();
for ( Map item : jsonData) {
configurations.add(new KerberosConfigurationDescriptor(item));
}
Assert.assertNotNull(configurations);
Assert.assertEquals(2,configurations.size());
for ( KerberosConfigurationDescriptor configuration : configurations) {
Assert.assertFalse(configuration.isContainer());
String type=configuration.getType();
Assert.assertEquals(2,configurations.size());
Map properties=configuration.getProperties();
if ("configuration-type".equals(type)) {
Assert.assertNotNull(properties);
Assert.assertEquals(2,properties.size());
Assert.assertEquals("value1",properties.get("property1"));
Assert.assertEquals("value2",properties.get("property2"));
}
else if ("configuration-type2".equals(type)) {
Assert.assertNotNull(properties);
Assert.assertEquals(3,properties.size());
Assert.assertEquals("value1",properties.get("property1"));
Assert.assertEquals("value2",properties.get("property2"));
Assert.assertEquals("value3",properties.get("property3"));
Assert.assertEquals("value1",configuration.getProperty("property1"));
Assert.assertEquals("value2",configuration.getProperty("property2"));
Assert.assertEquals("value3",configuration.getProperty("property3"));
}
else {
Assert.fail("Missing expected configuration type");
}
}
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier > jsonData=new Gson().fromJson(JSON_SINGLE_VALUE,new TypeToken>>(){
}
.getType());
KerberosConfigurationDescriptor configuration=new KerberosConfigurationDescriptor(jsonData);
KerberosConfigurationDescriptor updatedConfiguration=new KerberosConfigurationDescriptor(MAP_SINGLE_VALUE);
Map properties;
properties=configuration.getProperties();
Assert.assertEquals("configuration-type",configuration.getType());
Assert.assertNotNull(properties);
Assert.assertEquals(2,properties.size());
Assert.assertEquals("${property-value1}",properties.get("property1"));
Assert.assertEquals("${property.value2}",properties.get("property2"));
configuration.update(updatedConfiguration);
properties=configuration.getProperties();
Assert.assertEquals("configuration-type",configuration.getType());
Assert.assertNotNull(properties);
Assert.assertEquals(2,properties.size());
Assert.assertEquals("black",properties.get("property1"));
Assert.assertEquals("white",properties.get("property2"));
updatedConfiguration.setType("updated-type");
configuration.update(updatedConfiguration);
Assert.assertEquals("updated-type",configuration.getType());
Assert.assertNotNull(properties);
Assert.assertEquals(2,properties.size());
Assert.assertEquals("black",properties.get("property1"));
Assert.assertEquals("white",properties.get("property2"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier > jsonData=new Gson().fromJson(JSON_SINGLE_VALUE,new TypeToken>>(){
}
.getType());
KerberosConfigurationDescriptor configuration=new KerberosConfigurationDescriptor(jsonData);
Assert.assertNotNull(configuration);
Assert.assertFalse(configuration.isContainer());
Map properties=configuration.getProperties();
Assert.assertEquals("configuration-type",configuration.getType());
Assert.assertNotNull(properties);
Assert.assertEquals(2,properties.size());
Assert.assertEquals("${property-value1}",properties.get("property1"));
Assert.assertEquals("${property.value2}",properties.get("property2"));
}
BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier configurations=new ArrayList();
for ( Map> item : MAP_MULTIPLE_VALUES) {
configurations.add(new KerberosConfigurationDescriptor(item));
}
Assert.assertNotNull(configurations);
Assert.assertEquals(2,configurations.size());
for ( KerberosConfigurationDescriptor configuration : configurations) {
Assert.assertFalse(configuration.isContainer());
String type=configuration.getType();
Map properties=configuration.getProperties();
if ("configuration-type".equals(type)) {
Assert.assertNotNull(properties);
Assert.assertEquals(2,properties.size());
Assert.assertEquals("black",properties.get("property1"));
Assert.assertEquals("white",properties.get("property2"));
Assert.assertEquals("black",configuration.getProperty("property1"));
Assert.assertEquals("white",configuration.getProperty("property2"));
}
else if ("configuration-type2".equals(type)) {
Assert.assertNotNull(properties);
Assert.assertEquals(3,properties.size());
Assert.assertEquals("red",properties.get("property1"));
Assert.assertEquals("yellow",properties.get("property2"));
Assert.assertEquals("green",properties.get("property3"));
Assert.assertEquals("red",configuration.getProperty("property1"));
Assert.assertEquals("yellow",configuration.getProperty("property2"));
Assert.assertEquals("green",configuration.getProperty("property3"));
}
else {
Assert.fail("Missing expected configuration type");
}
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier properties=configuration.getProperties();
Assert.assertNotNull(configuration);
Assert.assertFalse(configuration.isContainer());
Assert.assertEquals("configuration-type",configuration.getType());
Assert.assertNotNull(properties);
Assert.assertEquals(2,properties.size());
Assert.assertEquals("black",properties.get("property1"));
Assert.assertEquals("white",properties.get("property2"));
}
Class: org.apache.ambari.server.state.kerberos.KerberosDescriptorTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier NullVerifier Class: org.apache.ambari.server.state.kerberos.KerberosPrincipalDescriptorTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.state.kerberos.VariableReplacementHelperTest InternalCallVerifier EqualityVerifier > configurations=new HashMap>(){
{
put("",new HashMap(){
{
put("delimited.data","one,two,three,four");
put("realm","UNIT.TEST");
}
}
);
put("clusterHostInfo",new HashMap(){
{
put("hive_metastore_host","host1.unit.test, host2.unit.test , host3.unit.test");
}
}
);
}
}
;
Assert.assertEquals("test=thrift://one:9083\\,thrift://two:9083\\,thrift://three:9083\\,thrift://four:9083",helper.replaceVariables("test=${delimited.data|each(thrift://%s:9083, \\\\,, \\s*\\,\\s*)}",configurations));
Assert.assertEquals("hive.metastore.local=false,hive.metastore.uris=thrift://host1.unit.test:9083\\,thrift://host2.unit.test:9083\\,thrift://host3.unit.test:9083,hive.metastore.sasl.enabled=true,hive.metastore.execute.setugi=true,hive.metastore.warehouse.dir=/apps/hive/warehouse,hive.exec.mode.local.auto=false,hive.metastore.kerberos.principal=hive/_HOST@UNIT.TEST",helper.replaceVariables("hive.metastore.local=false,hive.metastore.uris=${clusterHostInfo/hive_metastore_host | each(thrift://%s:9083, \\\\,, \\s*\\,\\s*)},hive.metastore.sasl.enabled=true,hive.metastore.execute.setugi=true,hive.metastore.warehouse.dir=/apps/hive/warehouse,hive.exec.mode.local.auto=false,hive.metastore.kerberos.principal=hive/_HOST@${realm}",configurations));
}
InternalCallVerifier EqualityVerifier > configurations=new HashMap>(){
{
put("",new HashMap(){
{
put("host","c6401.ambari.apache.org");
put("realm","EXAMPLE.COM");
}
}
);
}
}
;
Assert.assertEquals("hive.metastore.local=false,hive.metastore.uris=thrift://c6401.ambari.apache.org:9083,hive.metastore.sasl.enabled=true,hive.metastore.execute.setugi=true,hive.metastore.warehouse.dir=/apps/hive/warehouse,hive.exec.mode.local.auto=false,hive.metastore.kerberos.principal=hive/_HOST@EXAMPLE.COM",helper.replaceVariables("hive.metastore.local=false,hive.metastore.uris=thrift://${host}:9083,hive.metastore.sasl.enabled=true,hive.metastore.execute.setugi=true,hive.metastore.warehouse.dir=/apps/hive/warehouse,hive.exec.mode.local.auto=false,hive.metastore.kerberos.principal=hive/_HOST@${realm}",configurations));
Assert.assertEquals("Hello my realm is {EXAMPLE.COM}",helper.replaceVariables("Hello my realm is {${realm}}",configurations));
Assert.assertEquals("$c6401.ambari.apache.org",helper.replaceVariables("$${host}",configurations));
}
UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier > configurations=new HashMap>(){
{
put("",new HashMap(){
{
put("global_variable","Hello World");
put("variable-name","dash");
put("variable_name","underscore");
put("variable.name","dot");
}
}
);
put("config_type",new HashMap(){
{
put("variable-name","config_type_dash");
put("variable_name","config_type_underscore");
put("variable.name","config_type_dot");
}
}
);
put("config.type",new HashMap(){
{
put("variable-name","config.type_dash");
put("variable_name","config.type_underscore");
put("variable.name","config.type_dot");
}
}
);
put("config-type",new HashMap(){
{
put("variable.name","Replacement1");
put("variable.name1","${config-type2/variable.name}");
put("variable.name2","");
}
}
);
put("config-type2",new HashMap(){
{
put("variable.name","Replacement2");
put("self_reference","${config-type2/self_reference}");
put("${config-type/variable.name}_reference","Replacement in the key");
}
}
);
}
}
;
Assert.assertEquals("concrete",helper.replaceVariables("concrete",configurations));
Assert.assertEquals("Hello World",helper.replaceVariables("${global_variable}",configurations));
Assert.assertEquals("Replacement1",helper.replaceVariables("${config-type/variable.name}",configurations));
Assert.assertEquals("Replacement1|Replacement2",helper.replaceVariables("${config-type/variable.name}|${config-type2/variable.name}",configurations));
Assert.assertEquals("Replacement1|Replacement2|${config-type3/variable.name}",helper.replaceVariables("${config-type/variable.name}|${config-type2/variable.name}|${config-type3/variable.name}",configurations));
Assert.assertEquals("Replacement2|Replacement2",helper.replaceVariables("${config-type/variable.name1}|${config-type2/variable.name}",configurations));
Assert.assertEquals("Replacement1_reference",helper.replaceVariables("${config-type/variable.name}_reference",configurations));
Assert.assertEquals("dash",helper.replaceVariables("${variable-name}",configurations));
Assert.assertEquals("underscore",helper.replaceVariables("${variable_name}",configurations));
Assert.assertEquals("config_type_dot",helper.replaceVariables("${config_type/variable.name}",configurations));
Assert.assertEquals("config_type_dash",helper.replaceVariables("${config_type/variable-name}",configurations));
Assert.assertEquals("config_type_underscore",helper.replaceVariables("${config_type/variable_name}",configurations));
Assert.assertEquals("config.type_dot",helper.replaceVariables("${config.type/variable.name}",configurations));
Assert.assertEquals("config.type_dash",helper.replaceVariables("${config.type/variable-name}",configurations));
Assert.assertEquals("config.type_underscore",helper.replaceVariables("${config.type/variable_name}",configurations));
Assert.assertEquals("dot",helper.replaceVariables("${variable.name}",configurations));
Assert.assertEquals("",helper.replaceVariables("${config-type/variable.name2}",configurations));
try {
Assert.assertEquals("${config-type2/self_reference}",helper.replaceVariables("${config-type2/self_reference}",configurations));
Assert.fail(String.format("%s expected to be thrown",AmbariException.class.getName()));
}
catch ( AmbariException e) {
}
}
Class: org.apache.ambari.server.state.scheduler.BatchRequestJobTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier properties=new HashMap();
properties.put(BatchRequestJob.BATCH_REQUEST_FAILED_TASKS_KEY,10);
properties.put(BatchRequestJob.BATCH_REQUEST_TOTAL_TASKS_KEY,20);
expect(scheduleManagerMock.continueOnMisfire(executionContext)).andReturn(true);
expect(executionContext.getMergedJobDataMap()).andReturn(jobDataMap);
expect(executionContext.getJobDetail()).andReturn(jobDetail);
expect(jobDetail.getKey()).andReturn(JobKey.jobKey("testJob","testGroup"));
expect(jobDataMap.getWrappedMap()).andReturn(properties);
expect(jobDataMap.getString((String)anyObject())).andReturn("testJob").anyTimes();
Capture triggerCapture=new Capture();
scheduleManagerMock.scheduleJob(capture(triggerCapture));
expectLastCall().once();
replay(scheduleManagerMock,executionContext,jobDataMap,jobDetail);
batchRequestJobMock.execute(executionContext);
verify(scheduleManagerMock,executionContext,jobDataMap,jobDetail);
Trigger trigger=triggerCapture.getValue();
Assert.assertNotNull(trigger);
JobDataMap savedMap=trigger.getJobDataMap();
Assert.assertNotNull(savedMap);
Assert.assertEquals(10,savedMap.getIntValue(BatchRequestJob.BATCH_REQUEST_FAILED_TASKS_KEY));
Assert.assertEquals(20,savedMap.getIntValue(BatchRequestJob.BATCH_REQUEST_TOTAL_TASKS_KEY));
}
Class: org.apache.ambari.server.state.services.AlertNoticeDispatchServiceTest APIUtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier notices=getSingleMockNotice(dispatcher.getType());
AlertNoticeEntity notice=notices.get(0);
EasyMock.expect(m_dao.findPendingNotices()).andReturn(notices).once();
EasyMock.expect(m_dispatchFactory.getDispatcher("EMAIL")).andReturn(dispatcher).once();
EasyMock.expect(m_dao.merge(notice)).andReturn(notice).atLeastOnce();
EasyMock.replay(m_dao,m_dispatchFactory);
AlertNoticeDispatchService service=m_injector.getInstance(AlertNoticeDispatchService.class);
service.startUp();
service.setExecutor(new MockExecutor());
service.runOneIteration();
EasyMock.verify(m_dao,m_dispatchFactory);
Notification notification=dispatcher.getNotification();
assertNotNull(notification);
assertTrue(notification.Subject.contains("OK[1]"));
assertTrue(notification.Subject.contains("Critical[0]"));
assertTrue(notification.Body.contains(ALERT_UNIQUE_TEXT));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier NullVerifier notices=getSingleMockNotice(dispatcher.getType());
AlertNoticeEntity notice=notices.get(0);
EasyMock.expect(m_dao.findPendingNotices()).andReturn(notices).once();
EasyMock.expect(m_dao.merge(notice)).andReturn(notice).once();
EasyMock.expect(m_dao.findNoticeByUuid(ALERT_NOTICE_UUID_1)).andReturn(notice).once();
EasyMock.expect(m_dao.merge(notice)).andReturn(notice).once();
EasyMock.expect(m_dispatchFactory.getDispatcher(dispatcher.getType())).andReturn(dispatcher).once();
EasyMock.replay(m_dao,m_dispatchFactory);
AlertNoticeDispatchService service=m_injector.getInstance(AlertNoticeDispatchService.class);
service.setExecutor(new MockExecutor());
service.runOneIteration();
EasyMock.verify(m_dao,m_dispatchFactory);
Notification notification=dispatcher.getNotification();
assertNull(notification);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier notices=getSingleMockNotice(dispatcher.getType());
AlertNoticeEntity notice=notices.get(0);
EasyMock.expect(m_dao.findPendingNotices()).andReturn(notices).once();
EasyMock.expect(m_dao.merge(notice)).andReturn(notice).atLeastOnce();
EasyMock.expect(m_dispatchFactory.getDispatcher(dispatcher.getType())).andReturn(dispatcher).once();
EasyMock.replay(m_dao,m_dispatchFactory);
AlertNoticeDispatchService service=m_injector.getInstance(AlertNoticeDispatchService.class);
service.startUp();
service.setExecutor(new MockExecutor());
service.runOneIteration();
EasyMock.verify(m_dao,m_dispatchFactory);
Notification notification=dispatcher.getNotification();
assertNotNull(notification);
assertEquals(NotificationState.DISPATCHED,notice.getNotifyState());
}
Class: org.apache.ambari.server.state.stack.ConfigUpgradePackTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier changesByID=cup.enumerateConfigChangesByID();
ConfigUpgradeChangeDefinition hdp_2_1_1_nm_pre_upgrade=changesByID.get("hdp_2_1_1_nm_pre_upgrade");
assertEquals("core-site",hdp_2_1_1_nm_pre_upgrade.getConfigType());
assertEquals(4,hdp_2_1_1_nm_pre_upgrade.getTransfers().size());
ConfigUpgradeChangeDefinition.Transfer t1=hdp_2_1_1_nm_pre_upgrade.getTransfers().get(0);
assertEquals(TransferOperation.COPY,t1.operation);
assertEquals("copy-key",t1.fromKey);
assertEquals("copy-key-to",t1.toKey);
ConfigUpgradeChangeDefinition.Transfer t2=hdp_2_1_1_nm_pre_upgrade.getTransfers().get(1);
assertEquals(TransferOperation.COPY,t2.operation);
assertEquals("my-site",t2.fromType);
assertEquals("my-copy-key",t2.fromKey);
assertEquals("my-copy-key-to",t2.toKey);
assertTrue(t2.keepKeys.isEmpty());
ConfigUpgradeChangeDefinition.Transfer t3=hdp_2_1_1_nm_pre_upgrade.getTransfers().get(2);
assertEquals(TransferOperation.MOVE,t3.operation);
assertEquals("move-key",t3.fromKey);
assertEquals("move-key-to",t3.toKey);
ConfigUpgradeChangeDefinition.Transfer t4=hdp_2_1_1_nm_pre_upgrade.getTransfers().get(3);
assertEquals(TransferOperation.DELETE,t4.operation);
assertEquals("delete-key",t4.deleteKey);
assertNull(t4.toKey);
assertTrue(t4.preserveEdits);
assertEquals(1,t4.keepKeys.size());
assertEquals("important-key",t4.keepKeys.get(0));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier cups=new ArrayList<>();
for (int cupIndex=0; cupIndex < 3; cupIndex++) {
ArrayList services=new ArrayList<>();
for (int serviceIndex=0; serviceIndex < 2; serviceIndex++) {
String serviceName;
if (serviceIndex == 0) {
serviceName="HDFS";
}
else {
serviceName=String.format("SOME_SERVICE_%s",cupIndex);
}
ArrayList components=new ArrayList<>();
for (int componentIndex=0; componentIndex < 2; componentIndex++) {
String componentName;
if (componentIndex == 0) {
componentName="NAMENODE";
}
else {
componentName="SOME_COMPONENT_" + cupIndex;
}
ArrayList changeDefinitions=new ArrayList<>();
for (int changeIndex=0; changeIndex < 2; changeIndex++) {
String change_id=String.format("CHANGE_%s_%s_%s_%s",cupIndex,serviceIndex,componentIndex,changeIndex);
ConfigUpgradeChangeDefinition changeDefinition=new ConfigUpgradeChangeDefinition();
changeDefinition.id=change_id;
changeDefinitions.add(changeDefinition);
}
AffectedComponent component=new AffectedComponent();
component.name=componentName;
component.changes=changeDefinitions;
components.add(component);
}
AffectedService service=new AffectedService();
service.name=serviceName;
service.components=components;
services.add(service);
}
ConfigUpgradePack cupI=new ConfigUpgradePack();
cupI.services=services;
cups.add(cupI);
}
ConfigUpgradePack result=ConfigUpgradePack.merge(cups);
assertEquals(result.enumerateConfigChangesByID().entrySet().size(),24);
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("NAMENODE").changes.get(0).id,"CHANGE_0_0_0_0");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("NAMENODE").changes.get(1).id,"CHANGE_0_0_0_1");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("NAMENODE").changes.get(2).id,"CHANGE_1_0_0_0");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("NAMENODE").changes.get(3).id,"CHANGE_1_0_0_1");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("NAMENODE").changes.get(4).id,"CHANGE_2_0_0_0");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("NAMENODE").changes.get(5).id,"CHANGE_2_0_0_1");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("SOME_COMPONENT_0").changes.get(0).id,"CHANGE_0_0_1_0");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("SOME_COMPONENT_0").changes.get(1).id,"CHANGE_0_0_1_1");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("SOME_COMPONENT_1").changes.get(0).id,"CHANGE_1_0_1_0");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("SOME_COMPONENT_1").changes.get(1).id,"CHANGE_1_0_1_1");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("SOME_COMPONENT_2").changes.get(0).id,"CHANGE_2_0_1_0");
assertEquals(result.getServiceMap().get("HDFS").getComponentMap().get("SOME_COMPONENT_2").changes.get(1).id,"CHANGE_2_0_1_1");
assertEquals(result.getServiceMap().get("SOME_SERVICE_0").getComponentMap().get("NAMENODE").changes.get(0).id,"CHANGE_0_1_0_0");
assertEquals(result.getServiceMap().get("SOME_SERVICE_0").getComponentMap().get("NAMENODE").changes.get(1).id,"CHANGE_0_1_0_1");
assertEquals(result.getServiceMap().get("SOME_SERVICE_0").getComponentMap().get("SOME_COMPONENT_0").changes.get(0).id,"CHANGE_0_1_1_0");
assertEquals(result.getServiceMap().get("SOME_SERVICE_0").getComponentMap().get("SOME_COMPONENT_0").changes.get(1).id,"CHANGE_0_1_1_1");
assertEquals(result.getServiceMap().get("SOME_SERVICE_1").getComponentMap().get("NAMENODE").changes.get(0).id,"CHANGE_1_1_0_0");
assertEquals(result.getServiceMap().get("SOME_SERVICE_1").getComponentMap().get("NAMENODE").changes.get(1).id,"CHANGE_1_1_0_1");
assertEquals(result.getServiceMap().get("SOME_SERVICE_1").getComponentMap().get("SOME_COMPONENT_1").changes.get(0).id,"CHANGE_1_1_1_0");
assertEquals(result.getServiceMap().get("SOME_SERVICE_1").getComponentMap().get("SOME_COMPONENT_1").changes.get(1).id,"CHANGE_1_1_1_1");
assertEquals(result.getServiceMap().get("SOME_SERVICE_2").getComponentMap().get("NAMENODE").changes.get(0).id,"CHANGE_2_1_0_0");
assertEquals(result.getServiceMap().get("SOME_SERVICE_2").getComponentMap().get("NAMENODE").changes.get(1).id,"CHANGE_2_1_0_1");
assertEquals(result.getServiceMap().get("SOME_SERVICE_2").getComponentMap().get("SOME_COMPONENT_2").changes.get(0).id,"CHANGE_2_1_1_0");
assertEquals(result.getServiceMap().get("SOME_SERVICE_2").getComponentMap().get("SOME_COMPONENT_2").changes.get(1).id,"CHANGE_2_1_1_1");
}
Class: org.apache.ambari.server.state.stack.OSFamilyTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier actual_oslist=os_family.os_list();
Set expected_oslist=new HashSet(Arrays.asList("redhat6","oraclelinux5","suse11","fedora6","opensuse11","centos6","fedora5","centos5","ubuntu12","redhat5","sles11","oraclelinux6","debian12","sled11","win2012server6","win2012serverr26","win2008serverr26","win2008server6"));
Assert.assertNotNull(actual_oslist);
Assert.assertEquals(expected_oslist,actual_oslist);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier expected_set=new HashSet(Arrays.asList("ubuntu12","debian12"));
Set actual_set=os_family.findTypes("ubuntu12");
Assert.assertNotNull(actual_set);
Assert.assertEquals(expected_set,actual_set);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier expected_map=new HashMap();
expected_map.put("distro","ubuntu");
expected_map.put("versions","12");
String test_value="ubuntu12";
Class[] parse_os_args={String.class};
Method parse_os=os_family.getClass().getDeclaredMethod("parse_os",parse_os_args);
parse_os.setAccessible(true);
Object test_map=parse_os.invoke(os_family,test_value);
parse_os.setAccessible(false);
Assert.assertNotNull(test_map);
Assert.assertEquals(expected_map.getClass().getName(),test_map.getClass().getName());
Assert.assertEquals(expected_map,test_map);
}
Class: org.apache.ambari.server.state.stack.UpgradePackTest InternalCallVerifier BooleanVerifier upgrades=ambariMetaInfo.getUpgradePacks("foo","bar");
assertTrue(upgrades.isEmpty());
upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.size() > 0);
assertTrue(upgrades.containsKey("upgrade_test"));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
Set keys=upgrades.keySet();
for ( String key : keys) {
Assert.assertFalse(upgrades.get(key).isComponentFailureAutoSkipped());
Assert.assertFalse(upgrades.get(key).isServiceCheckFailureAutoSkipped());
}
upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.2.0");
UpgradePack upgradePack=upgrades.get("upgrade_test_skip_failures");
Assert.assertTrue(upgradePack.isComponentFailureAutoSkipped());
Assert.assertTrue(upgradePack.isServiceCheckFailureAutoSkipped());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.size() > 0);
assertTrue(upgrades.containsKey("upgrade_test_nonrolling"));
UpgradePack upgrade=upgrades.get("upgrade_test_nonrolling");
List expected_up=Arrays.asList("PRE_CLUSTER","Stop High-Level Daemons","Backups","Stop Low-Level Daemons","UPDATE_DESIRED_STACK_ID","ALL_HOST_OPS","ZOOKEEPER","HDFS","MR and YARN","POST_CLUSTER");
List expected_down=Arrays.asList("Restore Backups","UPDATE_DESIRED_STACK_ID","ALL_HOST_OPS","ZOOKEEPER","HDFS","MR and YARN","POST_CLUSTER");
Iterator itr_up=expected_up.iterator();
List upgrade_groups=upgrade.getGroups(Direction.UPGRADE);
for ( Grouping g : upgrade_groups) {
assertEquals(true,itr_up.hasNext());
assertEquals(itr_up.next(),g.name);
}
Iterator itr_down=expected_down.iterator();
List downgrade_groups=upgrade.getGroups(Direction.DOWNGRADE);
for ( Grouping g : downgrade_groups) {
assertEquals(true,itr_down.hasNext());
assertEquals(itr_down.next(),g.name);
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.size() > 0);
assertTrue(upgrades.containsKey("upgrade_test_nonrolling"));
UpgradePack upgrade=upgrades.get("upgrade_test_nonrolling");
assertTrue(upgrade.getType() == UpgradeType.NON_ROLLING);
List groups=upgrade.getGroups(Direction.UPGRADE);
assertEquals(10,groups.size());
Grouping group=null;
ClusterGrouping clusterGroup=null;
UpdateStackGrouping updateStackGroup=null;
StopGrouping stopGroup=null;
RestartGrouping restartGroup=null;
group=groups.get(0);
assertEquals(ClusterGrouping.class,group.getClass());
clusterGroup=(ClusterGrouping)group;
assertEquals("Prepare Upgrade",clusterGroup.title);
assertNull(clusterGroup.parallelScheduler);
group=groups.get(1);
assertEquals(StopGrouping.class,group.getClass());
stopGroup=(StopGrouping)group;
assertEquals("Stop Daemons for High-Level Services",stopGroup.title);
assertNotNull(stopGroup.parallelScheduler);
assertEquals(ParallelScheduler.DEFAULT_MAX_DEGREE_OF_PARALLELISM,stopGroup.parallelScheduler.maxDegreeOfParallelism);
group=groups.get(2);
assertEquals(ClusterGrouping.class,group.getClass());
clusterGroup=(ClusterGrouping)group;
assertEquals("Take Backups",clusterGroup.title);
assertNull(clusterGroup.parallelScheduler);
group=groups.get(3);
assertEquals(StopGrouping.class,group.getClass());
stopGroup=(StopGrouping)group;
assertEquals("Stop Daemons for Low-Level Services",stopGroup.title);
assertNotNull(stopGroup.parallelScheduler);
assertEquals(ParallelScheduler.DEFAULT_MAX_DEGREE_OF_PARALLELISM,stopGroup.parallelScheduler.maxDegreeOfParallelism);
group=groups.get(4);
assertEquals(UpdateStackGrouping.class,group.getClass());
updateStackGroup=(UpdateStackGrouping)group;
assertEquals("Update Desired Stack Id",updateStackGroup.title);
assertNull(updateStackGroup.parallelScheduler);
group=groups.get(5);
assertEquals(ClusterGrouping.class,group.getClass());
clusterGroup=(ClusterGrouping)group;
assertEquals("Set Version On All Hosts",clusterGroup.title);
assertNull(clusterGroup.parallelScheduler);
group=groups.get(6);
assertEquals(RestartGrouping.class,group.getClass());
restartGroup=(RestartGrouping)group;
assertEquals("Zookeeper",restartGroup.title);
assertNull(restartGroup.parallelScheduler);
group=groups.get(7);
assertEquals(RestartGrouping.class,group.getClass());
restartGroup=(RestartGrouping)group;
assertEquals("HDFS",restartGroup.title);
assertNotNull(restartGroup.parallelScheduler);
assertEquals(2,restartGroup.parallelScheduler.maxDegreeOfParallelism);
group=groups.get(8);
assertEquals(RestartGrouping.class,group.getClass());
restartGroup=(RestartGrouping)group;
assertEquals("MR and YARN",restartGroup.title);
assertNotNull(restartGroup.parallelScheduler);
assertEquals(ParallelScheduler.DEFAULT_MAX_DEGREE_OF_PARALLELISM,restartGroup.parallelScheduler.maxDegreeOfParallelism);
group=groups.get(9);
assertEquals(ClusterGrouping.class,group.getClass());
clusterGroup=(ClusterGrouping)group;
assertEquals("Finalize {{direction.text.proper}}",clusterGroup.title);
assertNull(clusterGroup.parallelScheduler);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.size() > 0);
assertTrue(upgrades.containsKey("upgrade_test_checks"));
UpgradePack upgrade=upgrades.get("upgrade_test_checks");
PrerequisiteCheckConfig prerequisiteCheckConfig=upgrade.getPrerequisiteCheckConfig();
assertNotNull(prerequisiteCheckConfig);
assertNotNull(prerequisiteCheckConfig.globalProperties);
assertTrue(prerequisiteCheckConfig.getGlobalProperties().containsKey("global-property-1"));
assertEquals("global-value-1",prerequisiteCheckConfig.getGlobalProperties().get("global-property-1"));
assertNotNull(prerequisiteCheckConfig.prerequisiteCheckProperties);
assertEquals(2,prerequisiteCheckConfig.prerequisiteCheckProperties.size());
assertNotNull(prerequisiteCheckConfig.getCheckProperties("org.apache.ambari.server.checks.ServicesMapReduceDistributedCacheCheck"));
assertTrue(prerequisiteCheckConfig.getCheckProperties("org.apache.ambari.server.checks.ServicesMapReduceDistributedCacheCheck").containsKey("dfs-protocols-regex"));
assertEquals("^([^:]*dfs|wasb|ecs):.*",prerequisiteCheckConfig.getCheckProperties("org.apache.ambari.server.checks.ServicesMapReduceDistributedCacheCheck").get("dfs-protocols-regex"));
assertNotNull(prerequisiteCheckConfig.getCheckProperties("org.apache.ambari.server.checks.ServicesTezDistributedCacheCheck"));
assertTrue(prerequisiteCheckConfig.getCheckProperties("org.apache.ambari.server.checks.ServicesTezDistributedCacheCheck").containsKey("dfs-protocols-regex"));
assertEquals("^([^:]*dfs|wasb|ecs):.*",prerequisiteCheckConfig.getCheckProperties("org.apache.ambari.server.checks.ServicesTezDistributedCacheCheck").get("dfs-protocols-regex"));
List expected_up=Arrays.asList("PRE_CLUSTER","ZOOKEEPER","CORE_MASTER","SERVICE_CHECK_1","CORE_SLAVES","SERVICE_CHECK_2","POST_CLUSTER");
List expected_down=Arrays.asList("PRE_CLUSTER","CORE_SLAVES","SERVICE_CHECK_2","CORE_MASTER","SERVICE_CHECK_1","ZOOKEEPER","POST_CLUSTER");
Grouping serviceCheckGroup=null;
int i=0;
List groups=upgrade.getGroups(Direction.UPGRADE);
for ( Grouping g : groups) {
assertEquals(expected_up.get(i),g.name);
i++;
if (g.name.equals("SERVICE_CHECK_1")) {
serviceCheckGroup=g;
}
}
List expected_priority=Arrays.asList("HDFS","HBASE","YARN");
assertNotNull(serviceCheckGroup);
assertEquals(ServiceCheckGrouping.class,serviceCheckGroup.getClass());
ServiceCheckGrouping scg=(ServiceCheckGrouping)serviceCheckGroup;
Set priorities=scg.getPriorities();
assertEquals(3,priorities.size());
i=0;
for ( String s : priorities) {
assertEquals(expected_priority.get(i++),s);
}
i=0;
groups=upgrade.getGroups(Direction.DOWNGRADE);
for ( Grouping g : groups) {
assertEquals(expected_down.get(i),g.name);
i++;
}
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.size() > 0);
assertTrue(upgrades.containsKey("upgrade_direction"));
UpgradePack upgrade=upgrades.get("upgrade_direction");
assertTrue(upgrade.getType() == UpgradeType.ROLLING);
List groups=upgrade.getGroups(Direction.UPGRADE);
assertEquals(4,groups.size());
Grouping group=groups.get(2);
assertEquals(ClusterGrouping.class,group.getClass());
ClusterGrouping cluster_group=(ClusterGrouping)group;
assertEquals("Run on All",group.title);
cluster_group=(ClusterGrouping)groups.get(3);
List stages=cluster_group.executionStages;
assertEquals(3,stages.size());
assertNotNull(stages.get(0).intendedDirection);
assertEquals(Direction.DOWNGRADE,stages.get(0).intendedDirection);
groups=upgrade.getGroups(Direction.DOWNGRADE);
assertEquals(3,groups.size());
group=groups.get(1);
assertEquals(ClusterGrouping.class,group.getClass());
assertEquals("Run on All",group.title);
group=groups.get(2);
assertEquals(ClusterGrouping.class,group.getClass());
assertEquals("Finalize Upgrade",group.title);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier PublicFieldVerifier HybridVerifier upgrades=ambariMetaInfo.getUpgradePacks("HDP","2.1.1");
assertTrue(upgrades.size() > 0);
assertTrue(upgrades.containsKey("upgrade_test"));
UpgradePack upgrade=upgrades.get("upgrade_test");
assertEquals("2.2.*.*",upgrade.getTarget());
Map> expectedStages=new LinkedHashMap>(){
{
put("ZOOKEEPER",Arrays.asList("ZOOKEEPER_SERVER"));
put("HDFS",Arrays.asList("NAMENODE","DATANODE"));
}
}
;
int i=0;
for ( Entry> entry : expectedStages.entrySet()) {
assertTrue(upgrade.getTasks().containsKey(entry.getKey()));
assertEquals(i++,indexOf(upgrade.getTasks(),entry.getKey()));
assertEquals(entry.getValue().size(),upgrade.getTasks().get(entry.getKey()).size());
int j=0;
for ( String comp : entry.getValue()) {
assertEquals(j++,indexOf(upgrade.getTasks().get(entry.getKey()),comp));
}
}
assertTrue(upgrade.getTasks().containsKey("HDFS"));
assertTrue(upgrade.getTasks().get("HDFS").containsKey("NAMENODE"));
ProcessingComponent pc=upgrade.getTasks().get("HDFS").get("NAMENODE");
assertNotNull(pc.preTasks);
assertNotNull(pc.postTasks);
assertNotNull(pc.tasks);
assertNull(pc.preDowngradeTasks);
assertNull(pc.postDowngradeTasks);
assertEquals(1,pc.tasks.size());
assertEquals(Task.Type.RESTART,pc.tasks.get(0).getType());
assertEquals(RestartTask.class,pc.tasks.get(0).getClass());
assertTrue(upgrade.getTasks().containsKey("ZOOKEEPER"));
assertTrue(upgrade.getTasks().get("ZOOKEEPER").containsKey("ZOOKEEPER_SERVER"));
pc=upgrade.getTasks().get("HDFS").get("DATANODE");
assertNotNull(pc.preDowngradeTasks);
assertEquals(0,pc.preDowngradeTasks.size());
assertNotNull(pc.postDowngradeTasks);
assertEquals(1,pc.postDowngradeTasks.size());
pc=upgrade.getTasks().get("ZOOKEEPER").get("ZOOKEEPER_SERVER");
assertNotNull(pc.preTasks);
assertEquals(1,pc.preTasks.size());
assertNotNull(pc.postTasks);
assertEquals(1,pc.postTasks.size());
assertNotNull(pc.tasks);
assertEquals(1,pc.tasks.size());
pc=upgrade.getTasks().get("YARN").get("NODEMANAGER");
assertNotNull(pc.preTasks);
assertEquals(2,pc.preTasks.size());
Task t=pc.preTasks.get(1);
assertEquals(ConfigureTask.class,t.getClass());
ConfigureTask ct=(ConfigureTask)t;
assertEquals("hdp_2_1_1_nm_pre_upgrade",ct.getId());
}
Class: org.apache.ambari.server.state.stack.upgrade.RepositoryVersionHelperTest InternalCallVerifier EqualityVerifier repositories=new ArrayList();
final RepositoryInfo repository=new RepositoryInfo();
repository.setBaseUrl("baseurl");
repository.setOsType("os");
repository.setRepoId("repoId");
repositories.add(repository);
final String serialized=helper.serializeOperatingSystems(repositories);
Assert.assertEquals("[{\"repositories\":[{\"Repositories/base_url\":\"baseurl\",\"Repositories/repo_id\":\"repoId\"}],\"OperatingSystems/os_type\":\"os\"}]",serialized);
}
Class: org.apache.ambari.server.state.stack.upgrade.StageWrapperBuilderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier mockStageWrappers=new ArrayList<>();
StageWrapper mockStageWrapper=EasyMock.createNiceMock(StageWrapper.class);
mockStageWrappers.add(mockStageWrapper);
builder.setMockStageWrappers(mockStageWrappers);
List stageWrappers=builder.build(upgradeContext);
Assert.assertEquals(2,stageWrappers.size());
StageWrapper skipSummaryWrapper=stageWrappers.get(1);
Assert.assertEquals(StageWrapper.Type.SERVER_SIDE_ACTION,skipSummaryWrapper.getType());
ServerActionTask task=(ServerActionTask)(skipSummaryWrapper.getTasks().get(0).getTasks().get(0));
Assert.assertEquals(AutoSkipFailedSummaryAction.class.getName(),task.implClass);
}
Class: org.apache.ambari.server.state.svccomphost.ServiceComponentHostTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier validStates=new HashSet();
validStates.add(State.INSTALLED);
validStates.add(State.INSTALL_FAILED);
validStates.add(State.UNKNOWN);
validStates.add(State.DISABLED);
for ( State state : validStates) {
sch.setState(state);
ServiceComponentHostEvent disableEvent=createEvent(impl,++timestamp,ServiceComponentHostEventType.HOST_SVCCOMP_DISABLE);
impl.handleEvent(disableEvent);
Assert.assertEquals(-1,impl.getLastOpStartTime());
Assert.assertEquals(-1,impl.getLastOpLastUpdateTime());
Assert.assertEquals(-1,impl.getLastOpEndTime());
Assert.assertEquals(State.DISABLED,impl.getState());
}
HashSet invalidStates=new HashSet();
invalidStates.add(State.INIT);
invalidStates.add(State.INSTALLING);
invalidStates.add(State.STARTING);
invalidStates.add(State.STARTED);
invalidStates.add(State.STOPPING);
invalidStates.add(State.UNINSTALLING);
invalidStates.add(State.UNINSTALLED);
invalidStates.add(State.UPGRADING);
for ( State state : invalidStates) {
sch.setState(state);
ServiceComponentHostEvent disableEvent=createEvent(impl,++timestamp,ServiceComponentHostEventType.HOST_SVCCOMP_DISABLE);
boolean exceptionThrown=false;
try {
impl.handleEvent(disableEvent);
}
catch ( Exception e) {
exceptionThrown=true;
}
Assert.assertTrue("Exception not thrown on invalid event",exceptionThrown);
Assert.assertEquals(-1,impl.getLastOpStartTime());
Assert.assertEquals(-1,impl.getLastOpLastUpdateTime());
Assert.assertEquals(-1,impl.getLastOpEndTime());
}
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier hostNames=new HashSet();
hostNames.add(hostName);
addHostsToCluster(clusterName,hostAttributes,hostNames);
Cluster cluster=clusters.getCluster(clusterName);
helper.getOrCreateRepositoryVersion(stackId,stackId.getStackVersion());
cluster.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
ServiceComponentHost sch1=createNewServiceComponentHost(cluster,"HDFS","NAMENODE",hostName);
ServiceComponentHost sch2=createNewServiceComponentHost(cluster,"HDFS","DATANODE",hostName);
ServiceComponentHost sch3=createNewServiceComponentHost(cluster,"MAPREDUCE2","HISTORYSERVER",hostName);
sch1.setDesiredState(State.INSTALLED);
sch1.setState(State.INSTALLING);
sch1.setStackVersion(new StackId(stackVersion));
sch2.setDesiredState(State.INSTALLED);
sch2.setState(State.INSTALLING);
sch2.setStackVersion(new StackId(stackVersion));
sch3.setDesiredState(State.INSTALLED);
sch3.setState(State.INSTALLING);
sch3.setStackVersion(new StackId(stackVersion));
Assert.assertFalse(sch1.convertToResponse().isStaleConfig());
Assert.assertFalse(sch2.convertToResponse().isStaleConfig());
makeConfig(cluster,"global","version1",new HashMap(){
{
put("a","b");
put("dfs_namenode_name_dir","/foo1");
put("mapred_log_dir_prefix","/foo2");
}
}
,new HashMap>());
makeConfig(cluster,"hdfs-site","version1",new HashMap(){
{
put("hdfs1","hdfs1value1");
}
}
,new HashMap>());
Map> actual=new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
put("hdfs-site",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
;
sch1.updateActualConfigs(actual);
sch2.updateActualConfigs(actual);
sch3.updateActualConfigs(actual);
makeConfig(cluster,"mapred-site","version1",new HashMap(){
{
put("a","c");
}
}
,new HashMap>(){
{
put("final",new HashMap(){
{
put("a","true");
}
}
);
}
}
);
Assert.assertFalse(sch1.convertToResponse().isStaleConfig());
Assert.assertFalse(sch2.convertToResponse().isStaleConfig());
Assert.assertTrue(sch3.convertToResponse().isStaleConfig());
actual=new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
put("mapred-site",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
;
sch3.setRestartRequired(false);
sch3.updateActualConfigs(actual);
Assert.assertFalse(sch3.convertToResponse().isStaleConfig());
Map> c1PropAttributes=new HashMap>();
c1PropAttributes.put("final",new HashMap());
c1PropAttributes.get("final").put("hdfs1","true");
makeConfig(cluster,"hdfs-site","version2",new HashMap(){
{
put("hdfs1","hdfs1value1");
}
}
,c1PropAttributes);
sch1.setRestartRequired(false);
sch2.setRestartRequired(false);
sch3.setRestartRequired(false);
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
Assert.assertFalse(sch3.convertToResponse().isStaleConfig());
Map> c2PropAttributes=new HashMap>();
c2PropAttributes.put("final",new HashMap());
c2PropAttributes.get("final").put("hdfs1","false");
makeConfig(cluster,"hdfs-site","version3",new HashMap(){
{
put("hdfs1","hdfs1value1");
}
}
,c2PropAttributes);
sch1.setRestartRequired(false);
sch2.setRestartRequired(false);
sch3.setRestartRequired(false);
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
Assert.assertFalse(sch3.convertToResponse().isStaleConfig());
makeConfig(cluster,"hdfs-site","version4",new HashMap(){
{
put("hdfs1","hdfs1value1");
}
}
,new HashMap>());
sch1.setRestartRequired(false);
sch2.setRestartRequired(false);
sch3.setRestartRequired(false);
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
Assert.assertFalse(sch3.convertToResponse().isStaleConfig());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier (),new HashMap());
configGroup.persist();
cluster.addConfigGroup(configGroup);
Map> actual=new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
put("core-site",new HashMap(){
{
put("tag","version1");
put(configGroup.getId().toString(),"version2");
}
}
);
}
}
;
sch.updateActualConfigs(actual);
Map confirm=sch.getActualConfigs();
Assert.assertEquals(2,confirm.size());
Assert.assertTrue(confirm.containsKey("global"));
Assert.assertTrue(confirm.containsKey("core-site"));
Assert.assertEquals(1,confirm.get("core-site").getConfigGroupOverrides().size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier hostNames=new HashSet();
hostNames.add(hostName);
addHostsToCluster(clusterName,hostAttributes,hostNames);
Cluster cluster=clusters.getCluster(clusterName);
helper.getOrCreateRepositoryVersion(stackId,stackId.getStackVersion());
cluster.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
HostEntity hostEntity=hostDAO.findByName(hostName);
ServiceComponentHost sch1=createNewServiceComponentHost(cluster,"HDFS","NAMENODE",hostName);
HostComponentDesiredStateDAO daoHostComponentDesiredState=injector.getInstance(HostComponentDesiredStateDAO.class);
HostComponentDesiredStateEntity entityHostComponentDesiredState;
HostComponentDesiredStateEntityPK pkHostComponentDesiredState=new HostComponentDesiredStateEntityPK();
pkHostComponentDesiredState.setClusterId(cluster.getClusterId());
pkHostComponentDesiredState.setComponentName(sch1.getServiceComponentName());
pkHostComponentDesiredState.setServiceName(sch1.getServiceName());
pkHostComponentDesiredState.setHostId(hostEntity.getHostId());
HostComponentStateDAO daoHostComponentState=injector.getInstance(HostComponentStateDAO.class);
HostComponentStateEntity entityHostComponentState;
for ( SecurityState state : SecurityState.values()) {
sch1.setSecurityState(state);
entityHostComponentState=daoHostComponentState.findByIndex(cluster.getClusterId(),sch1.getServiceName(),sch1.getServiceComponentName(),hostEntity.getHostId());
Assert.assertNotNull(entityHostComponentState);
Assert.assertEquals(state,entityHostComponentState.getSecurityState());
try {
sch1.setDesiredSecurityState(state);
Assert.assertTrue(state.isEndpoint());
entityHostComponentDesiredState=daoHostComponentDesiredState.findByPK(pkHostComponentDesiredState);
Assert.assertNotNull(entityHostComponentDesiredState);
Assert.assertEquals(state,entityHostComponentDesiredState.getSecurityState());
}
catch ( AmbariException e) {
Assert.assertFalse(state.isEndpoint());
}
}
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier hostNames=new HashSet();
hostNames.add(hostName);
addHostsToCluster(clusterName,hostAttributes,hostNames);
Cluster cluster=clusters.getCluster(clusterName);
helper.getOrCreateRepositoryVersion(stackId,stackId.getStackVersion());
cluster.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
HostEntity hostEntity=hostDAO.findByName(hostName);
Assert.assertNotNull(hostEntity);
ServiceComponentHost sch1=createNewServiceComponentHost(cluster,"HDFS","NAMENODE",hostName);
ServiceComponentHost sch2=createNewServiceComponentHost(cluster,"HDFS","DATANODE",hostName);
ServiceComponentHost sch3=createNewServiceComponentHost(cluster,"MAPREDUCE2","HISTORYSERVER",hostName);
HostComponentDesiredStateEntityPK pk=new HostComponentDesiredStateEntityPK();
pk.setClusterId(Long.valueOf(cluster.getClusterId()));
pk.setComponentName(sch1.getServiceComponentName());
pk.setServiceName(sch1.getServiceName());
pk.setHostId(hostEntity.getHostId());
HostComponentDesiredStateDAO dao=injector.getInstance(HostComponentDesiredStateDAO.class);
HostComponentDesiredStateEntity entity=dao.findByPK(pk);
Assert.assertEquals(MaintenanceState.OFF,entity.getMaintenanceState());
Assert.assertEquals(MaintenanceState.OFF,sch1.getMaintenanceState());
sch1.setMaintenanceState(MaintenanceState.ON);
Assert.assertEquals(MaintenanceState.ON,sch1.getMaintenanceState());
entity=dao.findByPK(pk);
Assert.assertEquals(MaintenanceState.ON,entity.getMaintenanceState());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier hostNames=new HashSet();
hostNames.add(hostName);
addHostsToCluster(clusterName,hostAttributes,hostNames);
final HostEntity hostEntity=hostDAO.findByName(hostName);
Assert.assertNotNull(hostEntity.getHostId());
Cluster cluster=clusters.getCluster(clusterName);
Assert.assertNotNull(cluster);
helper.getOrCreateRepositoryVersion(stackId,stackId.getStackVersion());
cluster.createClusterVersion(stackId,stackId.getStackVersion(),"admin",RepositoryVersionState.UPGRADING);
ServiceComponentHost sch1=createNewServiceComponentHost(cluster,"HDFS","NAMENODE",hostName);
ServiceComponentHost sch2=createNewServiceComponentHost(cluster,"HDFS","DATANODE",hostName);
ServiceComponentHost sch3=createNewServiceComponentHost(cluster,"MAPREDUCE2","HISTORYSERVER",hostName);
sch1.setDesiredState(State.INSTALLED);
sch1.setState(State.INSTALLING);
sch1.setStackVersion(new StackId(stackVersion));
sch2.setDesiredState(State.INSTALLED);
sch2.setState(State.INSTALLING);
sch2.setStackVersion(new StackId(stackVersion));
sch3.setDesiredState(State.INSTALLED);
sch3.setState(State.INSTALLING);
sch3.setStackVersion(new StackId(stackVersion));
Assert.assertFalse(sch1.convertToResponse().isStaleConfig());
Assert.assertFalse(sch2.convertToResponse().isStaleConfig());
makeConfig(cluster,"global","version1",new HashMap(){
{
put("a","b");
put("dfs_namenode_name_dir","/foo1");
put("mapred_log_dir_prefix","/foo2");
}
}
,new HashMap>());
Map> actual=new HashMap>(){
{
put("global",new HashMap(){
{
put("tag","version1");
}
}
);
}
}
;
sch1.updateActualConfigs(actual);
sch2.updateActualConfigs(actual);
sch3.updateActualConfigs(actual);
makeConfig(cluster,"foo","version1",new HashMap(){
{
put("a","c");
}
}
,new HashMap>());
Assert.assertFalse(sch1.convertToResponse().isStaleConfig());
Assert.assertFalse(sch2.convertToResponse().isStaleConfig());
makeConfig(cluster,"hdfs-site","version1",new HashMap(){
{
put("a","b");
}
}
,new HashMap>());
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
actual.put("hdfs-site",new HashMap(){
{
put("tag","version1");
}
}
);
sch1.updateActualConfigs(actual);
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
sch1.setRestartRequired(false);
Assert.assertFalse(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
sch2.updateActualConfigs(actual);
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
sch2.setRestartRequired(false);
Assert.assertFalse(sch1.convertToResponse().isStaleConfig());
Assert.assertFalse(sch2.convertToResponse().isStaleConfig());
makeConfig(cluster,"hdfs-site","version2",new HashMap(){
{
put("dfs.journalnode.http-address","http://foo");
}
}
,new HashMap>());
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
actual.get("hdfs-site").put("tag","version2");
sch1.updateActualConfigs(actual);
sch2.updateActualConfigs(actual);
sch1.setRestartRequired(false);
sch2.setRestartRequired(false);
Assert.assertFalse(sch1.convertToResponse().isStaleConfig());
Assert.assertFalse(sch2.convertToResponse().isStaleConfig());
final Host host=clusters.getHostsForCluster(clusterName).get(hostName);
Assert.assertNotNull(host);
final Config c=configFactory.createNew(cluster,"hdfs-site",new HashMap(){
{
put("dfs.journalnode.http-address","http://goo");
}
}
,new HashMap>());
c.setTag("version3");
c.persist();
cluster.addConfig(c);
host.addDesiredConfig(cluster.getClusterId(),true,"user",c);
ConfigGroup configGroup=configGroupFactory.createNew(cluster,"g1","t1","",new HashMap(){
{
put("hdfs-site",c);
}
}
,new HashMap(){
{
put(hostEntity.getHostId(),host);
}
}
);
configGroup.persist();
cluster.addConfigGroup(configGroup);
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
actual.get("hdfs-site").put(configGroup.getId().toString(),"version3");
sch2.updateActualConfigs(actual);
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
sch2.setRestartRequired(false);
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertFalse(sch2.convertToResponse().isStaleConfig());
sch1.updateActualConfigs(actual);
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
sch1.setRestartRequired(false);
Assert.assertFalse(sch1.convertToResponse().isStaleConfig());
Assert.assertFalse(sch2.convertToResponse().isStaleConfig());
makeConfig(cluster,"global","version2",new HashMap(){
{
put("a","b");
put("dfs_namenode_name_dir","/foo3");
put("mapred_log_dir_prefix","/foo2");
}
}
,new HashMap>());
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
Assert.assertFalse(sch3.convertToResponse().isStaleConfig());
makeConfig(cluster,"core-site","version1",new HashMap(){
{
put("a","b");
put("fs.trash.interval","360");
}
}
,new HashMap>());
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
Assert.assertTrue(sch3.convertToResponse().isStaleConfig());
actual.put("core-site",new HashMap(){
{
put("tag","version1");
}
}
);
sch1.updateActualConfigs(actual);
final Config c1=configFactory.createNew(cluster,"core-site",new HashMap(){
{
put("fs.trash.interval","400");
}
}
,new HashMap>());
c1.setTag("version2");
c1.persist();
cluster.addConfig(c1);
configGroup=configGroupFactory.createNew(cluster,"g2","t2","",new HashMap(){
{
put("core-site",c1);
}
}
,new HashMap(){
{
put(hostEntity.getHostId(),host);
}
}
);
configGroup.persist();
cluster.addConfigGroup(configGroup);
Assert.assertTrue(sch1.convertToResponse().isStaleConfig());
Assert.assertTrue(sch2.convertToResponse().isStaleConfig());
Assert.assertTrue(sch3.convertToResponse().isStaleConfig());
Long id=configGroup.getId();
HashMap tags=new HashMap(2);
tags.put("tag","version1");
tags.put(id.toString(),"version2");
actual.put("core-site",tags);
sch3.updateActualConfigs(actual);
Assert.assertTrue(sch3.convertToResponse().isStaleConfig());
sch3.setRestartRequired(false);
Assert.assertFalse(sch3.convertToResponse().isStaleConfig());
cluster.deleteConfigGroup(id);
Assert.assertNull(cluster.getConfigGroups().get(id));
sch3.updateActualConfigs(actual);
Assert.assertTrue(sch3.convertToResponse().isStaleConfig());
tags.remove(id.toString());
sch3.updateActualConfigs(actual);
Assert.assertTrue(sch3.convertToResponse().isStaleConfig());
sch3.setRestartRequired(false);
Assert.assertFalse(sch3.convertToResponse().isStaleConfig());
}
Class: org.apache.ambari.server.testing.DBInconsistencyTests InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier schList=clusters.getCluster(OrmTestHelper.CLUSTER_NAME).getServiceComponentHosts("HDFS","DATANODE");
Assert.assertNotNull(schList);
Collection scList=cluster.getService("HDFS").getServiceComponents().values();
Assert.assertNotNull(schList);
cluster.deleteService("HDFS");
List hostComponentDesiredStateEntities=hostComponentDesiredStateDAO.findAll();
Assert.assertTrue(hostComponentDesiredStateEntities == null || hostComponentDesiredStateEntities.isEmpty());
List serviceComponentDesiredStateEntities=serviceComponentDesiredStateDAO.findAll();
Assert.assertTrue(serviceComponentDesiredStateEntities == null || serviceComponentDesiredStateEntities.isEmpty());
EntityManager em=helper.getEntityManager();
final EntityTransaction txn=em.getTransaction();
txn.begin();
for ( ServiceComponentHost sch : schList) {
sch.setDesiredState(State.DISABLED);
}
for ( ServiceComponent sc : scList) {
sc.setDesiredState(State.DISABLED);
}
txn.commit();
hostComponentDesiredStateEntities=hostComponentDesiredStateDAO.findAll();
Assert.assertTrue(hostComponentDesiredStateEntities == null || hostComponentDesiredStateEntities.isEmpty());
serviceComponentDesiredStateEntities=serviceComponentDesiredStateDAO.findAll();
Assert.assertTrue(serviceComponentDesiredStateEntities == null || serviceComponentDesiredStateEntities.isEmpty());
}
InternalCallVerifier EqualityVerifier NullVerifier IgnoredMethod HybridVerifier Class: org.apache.ambari.server.topology.AmbariContextTest InternalCallVerifier BooleanVerifier > testDesiredConfigs=ImmutableMap.>builder().put("hdfs-site",ImmutableSet.of(testHdfsDesiredConfig2,testHdfsDesiredConfig3,testHdfsDesiredConfig1)).put("core-site",ImmutableSet.of(testCoreSiteDesiredConfig)).build();
expect(cluster.getAllDesiredConfigVersions()).andReturn(testDesiredConfigs).atLeastOnce();
replayAll();
boolean topologyResolved=context.isTopologyResolved(CLUSTER_ID);
assertTrue(topologyResolved);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier clusterRequestCapture=new Capture();
controller.createCluster(capture(clusterRequestCapture));
expectLastCall().once();
expect(cluster.getServices()).andReturn(clusterServices).anyTimes();
Capture> serviceRequestCapture=new Capture>();
Capture> serviceComponentRequestCapture=new Capture>();
serviceResourceProvider.createServices(capture(serviceRequestCapture));
expectLastCall().once();
componentResourceProvider.createComponents(capture(serviceComponentRequestCapture));
expectLastCall().once();
Capture serviceInstallRequestCapture=new Capture();
Capture serviceStartRequestCapture=new Capture();
Capture installPredicateCapture=new Capture();
Capture startPredicateCapture=new Capture();
expect(serviceResourceProvider.updateResources(capture(serviceInstallRequestCapture),capture(installPredicateCapture))).andReturn(null).once();
expect(serviceResourceProvider.updateResources(capture(serviceStartRequestCapture),capture(startPredicateCapture))).andReturn(null).once();
replayAll();
context.createAmbariResources(topology,CLUSTER_NAME,null);
ClusterRequest clusterRequest=clusterRequestCapture.getValue();
assertEquals(CLUSTER_NAME,clusterRequest.getClusterName());
assertEquals(String.format("%s-%s",STACK_NAME,STACK_VERSION),clusterRequest.getStackVersion());
Collection serviceRequests=serviceRequestCapture.getValue();
assertEquals(2,serviceRequests.size());
Collection servicesFound=new HashSet();
for ( ServiceRequest serviceRequest : serviceRequests) {
servicesFound.add(serviceRequest.getServiceName());
assertEquals(CLUSTER_NAME,serviceRequest.getClusterName());
}
assertTrue(servicesFound.size() == 2 && servicesFound.containsAll(Arrays.asList("service1","service2")));
Collection serviceComponentRequests=serviceComponentRequestCapture.getValue();
assertEquals(3,serviceComponentRequests.size());
Map> foundServiceComponents=new HashMap>();
for ( ServiceComponentRequest componentRequest : serviceComponentRequests) {
assertEquals(CLUSTER_NAME,componentRequest.getClusterName());
String serviceName=componentRequest.getServiceName();
Collection serviceComponents=foundServiceComponents.get(serviceName);
if (serviceComponents == null) {
serviceComponents=new HashSet();
foundServiceComponents.put(serviceName,serviceComponents);
}
serviceComponents.add(componentRequest.getComponentName());
}
assertEquals(2,foundServiceComponents.size());
Collection service1Components=foundServiceComponents.get("service1");
assertEquals(2,service1Components.size());
assertTrue(service1Components.containsAll(Arrays.asList("s1Component1","s1Component2")));
Collection service2Components=foundServiceComponents.get("service2");
assertEquals(1,service2Components.size());
assertTrue(service2Components.contains("s2Component1"));
Request installRequest=serviceInstallRequestCapture.getValue();
Set> installPropertiesSet=installRequest.getProperties();
assertEquals(1,installPropertiesSet.size());
Map installProperties=installPropertiesSet.iterator().next();
assertEquals(CLUSTER_NAME,installProperties.get(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID));
assertEquals("INSTALLED",installProperties.get(ServiceResourceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
assertEquals(new EqualsPredicate(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID,CLUSTER_NAME),installPredicateCapture.getValue());
Request startRequest=serviceStartRequestCapture.getValue();
Set> startPropertiesSet=startRequest.getProperties();
assertEquals(1,startPropertiesSet.size());
Map startProperties=startPropertiesSet.iterator().next();
assertEquals(CLUSTER_NAME,startProperties.get(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID));
assertEquals("STARTED",startProperties.get(ServiceResourceProvider.SERVICE_SERVICE_STATE_PROPERTY_ID));
assertEquals(new EqualsPredicate(ServiceResourceProvider.SERVICE_CLUSTER_NAME_PROPERTY_ID,CLUSTER_NAME),installPredicateCapture.getValue());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier emptyMap()).once();
expect(clusterController.ensureResourceProvider(Resource.Type.ConfigGroup)).andReturn(configGroupResourceProvider).once();
expect(configGroupResourceProvider.createResources(capture(configGroupRequestCapture))).andReturn(null).once();
configHelper.moveDeprecatedGlobals(stackId,group1Configuration.getFullProperties(1),CLUSTER_NAME);
replayAll();
context.registerHostWithConfigGroup(HOST1,topology,HOST_GROUP_1);
Set configGroupRequests=configGroupRequestCapture.getValue();
assertEquals(1,configGroupRequests.size());
ConfigGroupRequest configGroupRequest=configGroupRequests.iterator().next();
assertEquals(CLUSTER_NAME,configGroupRequest.getClusterName());
assertEquals("testBP:group1",configGroupRequest.getGroupName());
assertEquals("service1",configGroupRequest.getTag());
assertEquals("Host Group Configuration",configGroupRequest.getDescription());
Collection requestHosts=configGroupRequest.getHosts();
requestHosts.retainAll(group1Hosts);
assertEquals(group1Hosts.size(),requestHosts.size());
Map requestConfig=configGroupRequest.getConfigs();
assertEquals(1,requestConfig.size());
Config type1Config=requestConfig.get("type1");
assertEquals("type1",type1Config.getType());
assertEquals("group1",type1Config.getTag());
Map requestProps=type1Config.getProperties();
assertEquals(3,requestProps.size());
assertEquals("val1.2",requestProps.get("prop1"));
assertEquals("val2",requestProps.get("prop2"));
assertEquals("val3",requestProps.get("prop3"));
}
InternalCallVerifier BooleanVerifier > testDesiredConfigs=ImmutableMap.>builder().put("hdfs-site",ImmutableSet.of(testHdfsDesiredConfig2,testHdfsDesiredConfig3,testHdfsDesiredConfig1)).put("core-site",ImmutableSet.of(testCoreSiteDesiredConfig)).build();
expect(cluster.getAllDesiredConfigVersions()).andReturn(testDesiredConfigs).atLeastOnce();
replayAll();
boolean topologyResolved=context.isTopologyResolved(CLUSTER_ID);
assertFalse(topologyResolved);
}
InternalCallVerifier BooleanVerifier > testDesiredConfigs=ImmutableMap.>builder().put("hdfs-site",ImmutableSet.of(testHdfsDesiredConfig1)).put("core-site",ImmutableSet.of(testCoreSiteDesiredConfig)).build();
expect(cluster.getAllDesiredConfigVersions()).andReturn(testDesiredConfigs).atLeastOnce();
replayAll();
boolean topologyResolved=context.isTopologyResolved(CLUSTER_ID);
assertFalse(topologyResolved);
}
Class: org.apache.ambari.server.topology.AsyncCallableServiceTest InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier hangingTask=new Callable(){
@Override public Boolean call() throws Exception {
Thread.sleep(10000000);
return false;
}
}
;
asyncCallableService=new AsyncCallableService(hangingTask,timeout,delay,Executors.newScheduledThreadPool(2));
Boolean serviceResult=asyncCallableService.call();
Assert.assertNotNull("Service result must not be null",serviceResult);
Assert.assertFalse("The expected boolean result is 'false'!",serviceResult);
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier hangingTask=new Callable(){
@Override public Boolean call() throws Exception {
throw new IllegalStateException("****************** TESTING ****************");
}
}
;
asyncCallableService=new AsyncCallableService(hangingTask,timeout,delay,Executors.newScheduledThreadPool(2));
Boolean serviceResult=asyncCallableService.call();
Assert.assertNotNull("Service result must not be null",serviceResult);
Assert.assertFalse("The expected boolean result is 'false'!",serviceResult);
}
InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.topology.BlueprintFactoryTest APIUtilityVerifier InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier HybridVerifier props=BlueprintResourceProviderTest.getBlueprintTestProperties().iterator().next();
replay(stack,dao,entity,configEntity);
Blueprint blueprint=testFactory.createBlueprint(props,null);
assertEquals(BLUEPRINT_NAME,blueprint.getName());
assertSame(stack,blueprint.getStack());
assertEquals(2,blueprint.getHostGroups().size());
Map hostGroups=blueprint.getHostGroups();
HostGroup group1=hostGroups.get("group1");
assertEquals("group1",group1.getName());
assertEquals("1",group1.getCardinality());
Collection components=group1.getComponentNames();
assertEquals(2,components.size());
assertTrue(components.contains("component1"));
assertTrue(components.contains("component2"));
Collection services=group1.getServices();
assertEquals(2,services.size());
assertTrue(services.contains("test-service1"));
assertTrue(services.contains("test-service2"));
assertTrue(group1.containsMasterComponent());
Configuration configuration=group1.getConfiguration();
assertTrue(configuration.getProperties().isEmpty());
assertTrue(configuration.getAttributes().isEmpty());
HostGroup group2=hostGroups.get("group2");
assertEquals("group2",group2.getName());
assertEquals("2",group2.getCardinality());
components=group2.getComponentNames();
assertEquals(1,components.size());
assertTrue(components.contains("component1"));
services=group2.getServices();
assertEquals(1,services.size());
assertTrue(services.contains("test-service1"));
assertTrue(group2.containsMasterComponent());
configuration=group2.getConfiguration();
assertTrue(configuration.getProperties().isEmpty());
assertTrue(configuration.getAttributes().isEmpty());
verify(dao,entity,configEntity);
}
Class: org.apache.ambari.server.topology.BlueprintImplTest InternalCallVerifier BooleanVerifier hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
Collection group1Components=new HashSet();
group1Components.add("c1");
group1Components.add("c2");
Set group2Components=new HashSet();
group2Components.add("c1");
group2Components.add("c3");
Collection requiredHDFSProperties=new HashSet();
requiredHDFSProperties.add(new Stack.ConfigProperty("hdfs-site","foo",null));
requiredHDFSProperties.add(new Stack.ConfigProperty("hdfs-site","bar",null));
requiredHDFSProperties.add(new Stack.ConfigProperty("hdfs-site","some_password",null));
requiredHDFSProperties.add(new Stack.ConfigProperty("category1","prop1",null));
Collection requiredService2Properties=new HashSet();
requiredService2Properties.add(new Stack.ConfigProperty("category2","prop2",null));
expect(stack.getServiceForComponent("c1")).andReturn("HDFS").atLeastOnce();
expect(stack.getServiceForComponent("c2")).andReturn("HDFS").atLeastOnce();
expect(stack.getServiceForComponent("c3")).andReturn("SERVICE2").atLeastOnce();
expect(stack.getRequiredConfigurationProperties("HDFS")).andReturn(requiredHDFSProperties).atLeastOnce();
expect(stack.getRequiredConfigurationProperties("SERVICE2")).andReturn(requiredService2Properties).atLeastOnce();
expect(stack.isPasswordProperty("HDFS","hdfs-site","foo")).andReturn(false).atLeastOnce();
expect(stack.isPasswordProperty("HDFS","hdfs-site","bar")).andReturn(false).atLeastOnce();
expect(stack.isPasswordProperty("HDFS","hdfs-site","some_password")).andReturn(true).atLeastOnce();
expect(stack.isPasswordProperty("HDFS","category1","prop1")).andReturn(false).atLeastOnce();
expect(stack.isPasswordProperty("SERVICE2","category2","prop2")).andReturn(false).atLeastOnce();
expect(group1.getConfiguration()).andReturn(EMPTY_CONFIGURATION).atLeastOnce();
expect(group1.getName()).andReturn("group1").anyTimes();
expect(group1.getComponentNames()).andReturn(group1Components).atLeastOnce();
expect(group1.getCardinality()).andReturn("1").atLeastOnce();
expect(group1.getComponents()).andReturn(Arrays.asList(new Component("c1"),new Component("c2"))).atLeastOnce();
expect(group2.getConfiguration()).andReturn(EMPTY_CONFIGURATION).atLeastOnce();
expect(group2.getName()).andReturn("group2").anyTimes();
expect(group2.getComponentNames()).andReturn(group2Components).atLeastOnce();
expect(group2.getCardinality()).andReturn("1").atLeastOnce();
expect(group2.getComponents()).andReturn(Arrays.asList(new Component("c1"),new Component("c3"))).atLeastOnce();
replay(stack,group1,group2);
Map> properties=new HashMap>();
Map hdfsProps=new HashMap();
properties.put("hdfs-site",hdfsProps);
hdfsProps.put("foo","val");
hdfsProps.put("bar","val");
Map category1Props=new HashMap();
properties.put("category1",category1Props);
category1Props.put("prop1","val");
Map category2Props=new HashMap();
properties.put("category2",category2Props);
category2Props.put("prop2","val");
Map>> attributes=new HashMap>>();
Configuration configuration=new Configuration(properties,attributes,EMPTY_CONFIGURATION);
SecurityConfiguration securityConfiguration=new SecurityConfiguration(SecurityType.KERBEROS,"testRef",null);
Blueprint blueprint=new BlueprintImpl("test",hostGroups,stack,configuration,securityConfiguration);
blueprint.validateRequiredProperties();
BlueprintEntity entity=blueprint.toEntity();
verify(stack,group1,group2);
assertTrue(entity.getSecurityType() == SecurityType.KERBEROS);
assertTrue(entity.getSecurityDescriptorReference().equals("testRef"));
}
InternalCallVerifier BooleanVerifier hostGroups=new HashSet();
hostGroups.add(group1);
hostGroups.add(group2);
Set group1Components=new HashSet();
group1Components.add("c1");
group1Components.add("c2");
Set group2Components=new HashSet();
group2Components.add("c1");
group2Components.add("c3");
Map> group2Props=new HashMap>();
Map group2Category2Props=new HashMap();
group2Props.put("category2",group2Category2Props);
group2Category2Props.put("prop2","val");
Collection requiredHDFSProperties=new HashSet();
requiredHDFSProperties.add(new Stack.ConfigProperty("hdfs-site","foo",null));
requiredHDFSProperties.add(new Stack.ConfigProperty("hdfs-site","bar",null));
requiredHDFSProperties.add(new Stack.ConfigProperty("hdfs-site","some_password",null));
requiredHDFSProperties.add(new Stack.ConfigProperty("category1","prop1",null));
Collection requiredService2Properties=new HashSet();
requiredService2Properties.add(new Stack.ConfigProperty("category2","prop2",null));
expect(stack.getServiceForComponent("c1")).andReturn("HDFS").atLeastOnce();
expect(stack.getServiceForComponent("c2")).andReturn("HDFS").atLeastOnce();
expect(stack.getServiceForComponent("c3")).andReturn("SERVICE2").atLeastOnce();
expect(stack.getRequiredConfigurationProperties("HDFS")).andReturn(requiredHDFSProperties).atLeastOnce();
expect(stack.getRequiredConfigurationProperties("SERVICE2")).andReturn(requiredService2Properties).atLeastOnce();
expect(stack.isPasswordProperty("HDFS","hdfs-site","foo")).andReturn(false).atLeastOnce();
expect(stack.isPasswordProperty("HDFS","hdfs-site","bar")).andReturn(false).atLeastOnce();
expect(stack.isPasswordProperty("HDFS","hdfs-site","some_password")).andReturn(true).atLeastOnce();
expect(stack.isPasswordProperty("HDFS","category1","prop1")).andReturn(false).atLeastOnce();
expect(stack.isPasswordProperty("SERVICE2","category2","prop2")).andReturn(false).atLeastOnce();
expect(group1.getConfiguration()).andReturn(EMPTY_CONFIGURATION).atLeastOnce();
expect(group1.getName()).andReturn("group1").anyTimes();
expect(group1.getComponentNames()).andReturn(group1Components).atLeastOnce();
expect(group1.getCardinality()).andReturn("1").atLeastOnce();
expect(group1.getComponents()).andReturn(Arrays.asList(new Component("c1"),new Component("c2"))).atLeastOnce();
expect(group2.getName()).andReturn("group2").anyTimes();
expect(group2.getComponentNames()).andReturn(group2Components).atLeastOnce();
expect(group2.getCardinality()).andReturn("1").atLeastOnce();
expect(group2.getComponents()).andReturn(Arrays.asList(new Component("c1"),new Component("c3"))).atLeastOnce();
Map> properties=new HashMap>();
Map hdfsProps=new HashMap();
properties.put("hdfs-site",hdfsProps);
hdfsProps.put("foo","val");
hdfsProps.put("bar","val");
Map category1Props=new HashMap();
properties.put("category1",category1Props);
category1Props.put("prop1","val");
Map>> attributes=new HashMap>>();
Configuration configuration=new Configuration(properties,attributes,EMPTY_CONFIGURATION);
Configuration group2Configuration=new Configuration(group2Props,EMPTY_ATTRIBUTES,configuration);
expect(group2.getConfiguration()).andReturn(group2Configuration).atLeastOnce();
replay(stack,group1,group2);
Blueprint blueprint=new BlueprintImpl("test",hostGroups,stack,configuration,null);
blueprint.validateRequiredProperties();
BlueprintEntity entity=blueprint.toEntity();
verify(stack,group1,group2);
assertTrue(entity.getSecurityType() == SecurityType.NONE);
assertTrue(entity.getSecurityDescriptorReference() == null);
}
Class: org.apache.ambari.server.topology.ConfigurationFactoryTest APIUtilityVerifier InternalCallVerifier EqualityVerifier > properties=configuration.getProperties();
assertEquals(2,properties.size());
Map configProperties1=properties.get("foo-type");
assertEquals(2,configProperties1.size());
assertEquals("prop1Value",configProperties1.get("prop1"));
assertEquals("prop2Value",configProperties1.get("prop2"));
Map configProperties2=properties.get("bar-type");
assertEquals(1,configProperties2.size());
assertEquals("prop3Value",configProperties2.get("prop3"));
Map>> attributes=configuration.getAttributes();
assertEquals(2,attributes.size());
Map> configType1Attributes=attributes.get("foo-type");
assertEquals(3,configType1Attributes.size());
Map configType1Prop1Attributes=configType1Attributes.get("prop1");
assertEquals(2,configType1Prop1Attributes.size());
assertEquals("attribute1-prop1-value",configType1Prop1Attributes.get("attribute1"));
assertEquals("attribute2-prop1-value",configType1Prop1Attributes.get("attribute2"));
Map configType1Prop2Attributes=configType1Attributes.get("prop2");
assertEquals(1,configType1Prop2Attributes.size());
assertEquals("attribute1-prop2-value",configType1Prop2Attributes.get("attribute1"));
Map configType1Prop3Attributes=configType1Attributes.get("prop3");
assertEquals(1,configType1Prop3Attributes.size());
assertEquals("attribute1-prop3-value",configType1Prop3Attributes.get("attribute1"));
Map> configType2Attributes=attributes.get("foobar-type");
assertEquals(2,configType2Attributes.size());
Map configType2Prop1Attributes=configType2Attributes.get("prop10");
assertEquals(1,configType2Prop1Attributes.size());
assertEquals("attribute1-prop10-value",configType2Prop1Attributes.get("attribute1"));
Map configType2Prop2Attributes=configType2Attributes.get("prop11");
assertEquals(1,configType2Prop2Attributes.size());
assertEquals("attribute10-prop11-value",configType2Prop2Attributes.get("attribute10"));
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier configProperties1=configuration.getProperties().get("foo-type");
assertEquals(2,configProperties1.size());
assertEquals("prop1Value",configProperties1.get("prop1"));
assertEquals("prop2Value",configProperties1.get("prop2"));
Map configProperties2=configuration.getProperties().get("bar-type");
assertEquals(1,configProperties2.size());
assertEquals("prop3Value",configProperties2.get("prop3"));
assertTrue(configuration.getAttributes().isEmpty());
}
Class: org.apache.ambari.server.topology.ConfigurationTest InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProperties1=new HashMap();
typeProperties1.put("prop1","val1");
typeProperties1.put("prop2","val2");
Map typeProperties2=new HashMap();
typeProperties2.put("prop1","val1");
typeProperties2.put("prop3","val3");
properties.put("type1",typeProperties1);
properties.put("type2",typeProperties2);
Configuration configuration=new Configuration(properties,EMPTY_ATTRIBUTES);
assertEquals(properties,configuration.getFullProperties());
assertEquals(EMPTY_ATTRIBUTES,configuration.getAttributes());
}
InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProperties1=new HashMap();
typeProperties1.put("prop1","val1");
typeProperties1.put("prop2","val2");
Map typeProperties2=new HashMap();
typeProperties2.put("prop1","val1");
typeProperties2.put("prop3","val3");
properties.put("type1",typeProperties1);
properties.put("type2",typeProperties2);
Map> parentProperties=new HashMap>();
Map parentTypeProperties1=new HashMap();
parentTypeProperties1.put("prop5","val5");
Map parentTypeProperties3=new HashMap();
parentTypeProperties3.put("prop6","val6");
parentProperties.put("type1",parentTypeProperties1);
parentProperties.put("type3",parentTypeProperties3);
Configuration parentConfiguration=new Configuration(parentProperties,EMPTY_ATTRIBUTES);
Configuration configuration=new Configuration(properties,EMPTY_ATTRIBUTES,parentConfiguration);
assertEquals(properties,configuration.getProperties());
assertEquals(EMPTY_ATTRIBUTES,configuration.getAttributes());
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier >> attributes=new HashMap>>();
Map> attributeProperties=new HashMap>();
Map properties1=new HashMap();
properties1.put("prop1","val1");
properties1.put("prop2","val2");
Map properties2=new HashMap();
properties2.put("prop1","val3");
attributeProperties.put("attribute1",properties1);
attributeProperties.put("attribute2",properties2);
attributes.put("type1",attributeProperties);
Configuration configuration=new Configuration(EMPTY_PROPERTIES,attributes);
assertEquals(attributes,configuration.getAttributes());
assertEquals(EMPTY_PROPERTIES,configuration.getProperties());
}
InternalCallVerifier EqualityVerifier > properties=new HashMap>();
Map typeProperties1=new HashMap();
typeProperties1.put("prop1","val1");
typeProperties1.put("prop2","val2");
Map typeProperties2=new HashMap();
typeProperties2.put("prop1","val1");
typeProperties2.put("prop3","val3");
properties.put("type1",typeProperties1);
properties.put("type2",typeProperties2);
Configuration configuration=new Configuration(properties,EMPTY_ATTRIBUTES);
assertEquals(properties,configuration.getProperties());
assertEquals(EMPTY_ATTRIBUTES,configuration.getAttributes());
}
InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier >> fullAttributes=configuration.getFullAttributes();
assertEquals(2,fullAttributes.size());
Map> type1Attributes=fullAttributes.get("type1");
assertEquals(4,type1Attributes.size());
Map attribute1Properties=type1Attributes.get("attribute1");
assertEquals(5,attribute1Properties.size());
assertEquals("val1.3",attribute1Properties.get("prop1"));
assertEquals("val2.2",attribute1Properties.get("prop2"));
assertEquals("val3.1",attribute1Properties.get("prop3"));
assertEquals("val6.2",attribute1Properties.get("prop6"));
assertEquals("val9.3",attribute1Properties.get("prop9"));
Map attribute2Properties=type1Attributes.get("attribute2");
assertEquals(2,attribute2Properties.size());
assertEquals("val4.3",attribute2Properties.get("prop4"));
assertEquals("val5.1",attribute2Properties.get("prop5"));
Map attribute3Properties=type1Attributes.get("attribute3");
assertEquals(2,attribute3Properties.size());
assertEquals("val7.3",attribute3Properties.get("prop7"));
assertEquals("val8.2",attribute3Properties.get("prop8"));
Map attribute4Properties=type1Attributes.get("attribute4");
assertEquals(2,attribute4Properties.size());
assertEquals("val10.3",attribute4Properties.get("prop10"));
assertEquals("val11.3",attribute4Properties.get("prop11"));
Map> type2Attributes=fullAttributes.get("type2");
assertEquals(2,type2Attributes.size());
Map attribute100Properties=type2Attributes.get("attribute100");
assertEquals(3,attribute100Properties.size());
assertEquals("val100.3",attribute100Properties.get("prop100"));
assertEquals("val101.1",attribute100Properties.get("prop101"));
assertEquals("val102.3",attribute100Properties.get("prop102"));
Map attribute101Properties=type2Attributes.get("attribute101");
assertEquals(2,attribute101Properties.size());
assertEquals("val100.2",attribute101Properties.get("prop100"));
assertEquals("val101.1",attribute101Properties.get("prop101"));
Configuration expectedConfiguration=createConfigurationWithParents_AttributesOnly();
assertEquals(expectedConfiguration.getAttributes(),configuration.getAttributes());
assertEquals(expectedConfiguration.getParentConfiguration().getAttributes(),configuration.getParentConfiguration().getAttributes());
assertEquals(expectedConfiguration.getParentConfiguration().getParentConfiguration().getAttributes(),configuration.getParentConfiguration().getParentConfiguration().getAttributes());
assertEquals(EMPTY_PROPERTIES,configuration.getProperties());
Collection configTypes=configuration.getAllConfigTypes();
assertEquals(2,configTypes.size());
assertTrue(configTypes.containsAll(Arrays.asList("type1","type2")));
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > fullProperties=configuration.getFullProperties();
assertEquals(4,fullProperties.size());
Map type1Props=fullProperties.get("type1");
assertEquals(5,type1Props.size());
assertEquals("val1.3",type1Props.get("prop1"));
assertEquals("val2.2",type1Props.get("prop2"));
assertEquals("val3.1",type1Props.get("prop3"));
assertEquals("val6.2",type1Props.get("prop6"));
assertEquals("val9.3",type1Props.get("prop9"));
Map type2Props=fullProperties.get("type2");
assertEquals(2,type2Props.size());
assertEquals("val4.3",type2Props.get("prop4"));
assertEquals("val5.1",type2Props.get("prop5"));
Map type3Props=fullProperties.get("type3");
assertEquals(2,type3Props.size());
assertEquals("val7.3",type3Props.get("prop7"));
assertEquals("val8.2",type3Props.get("prop8"));
Map type4Props=fullProperties.get("type4");
assertEquals(2,type4Props.size());
assertEquals("val10.3",type4Props.get("prop10"));
assertEquals("val11.3",type4Props.get("prop11"));
Configuration expectedConfiguration=createConfigurationWithParents_PropsOnly();
assertEquals(expectedConfiguration.getProperties(),configuration.getProperties());
assertEquals(expectedConfiguration.getParentConfiguration().getProperties(),configuration.getParentConfiguration().getProperties());
assertEquals(expectedConfiguration.getParentConfiguration().getParentConfiguration().getProperties(),configuration.getParentConfiguration().getParentConfiguration().getProperties());
assertEquals(EMPTY_ATTRIBUTES,configuration.getAttributes());
Collection configTypes=configuration.getAllConfigTypes();
assertEquals(4,configTypes.size());
assertTrue(configTypes.containsAll(Arrays.asList("type1","type2","type3","type4")));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > fullProperties=configuration.getFullProperties(1);
assertEquals(4,fullProperties.size());
Map type1Props=fullProperties.get("type1");
assertEquals(4,type1Props.size());
assertEquals("val1.3",type1Props.get("prop1"));
assertEquals("val2.2",type1Props.get("prop2"));
assertEquals("val6.2",type1Props.get("prop6"));
assertEquals("val9.3",type1Props.get("prop9"));
Map type2Props=fullProperties.get("type2");
assertEquals(1,type2Props.size());
assertEquals("val4.3",type2Props.get("prop4"));
Map type3Props=fullProperties.get("type3");
assertEquals(2,type3Props.size());
assertEquals("val7.3",type3Props.get("prop7"));
assertEquals("val8.2",type3Props.get("prop8"));
Map type4Props=fullProperties.get("type4");
assertEquals(2,type4Props.size());
assertEquals("val10.3",type4Props.get("prop10"));
assertEquals("val11.3",type4Props.get("prop11"));
Configuration expectedConfiguration=createConfigurationWithParents_PropsOnly();
assertEquals(expectedConfiguration.getProperties(),configuration.getProperties());
assertEquals(expectedConfiguration.getParentConfiguration().getProperties(),configuration.getParentConfiguration().getProperties());
assertEquals(expectedConfiguration.getParentConfiguration().getParentConfiguration().getProperties(),configuration.getParentConfiguration().getParentConfiguration().getProperties());
assertEquals(EMPTY_ATTRIBUTES,configuration.getAttributes());
}
Class: org.apache.ambari.server.topology.ConfigureClusterTaskTest InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.topology.HostGroupInfoTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hostNames=group.getHostNames();
assertEquals(3,hostNames.size());
assertTrue(hostNames.contains("host1"));
assertTrue(hostNames.contains("host2"));
assertTrue(hostNames.contains("host3"));
hostNames.clear();
hostNames=group.getHostNames();
assertEquals(3,hostNames.size());
assertTrue(hostNames.contains("host1"));
assertTrue(hostNames.contains("host2"));
assertTrue(hostNames.contains("host3"));
}
InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier IdentityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.topology.RequiredPasswordValidatorTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.topology.SecurityConfigurationFactoryTest InternalCallVerifier BooleanVerifier ExceptionVerifier HybridVerifier reuqestMap=new HashMap<>();
Map security=new HashMap<>();
security.put(SecurityConfigurationFactory.TYPE_PROPERTY_ID,"INVALID_SECURITY_TYPE");
reuqestMap.put(SecurityConfigurationFactory.SECURITY_PROPERTY_ID,security);
SecurityConfiguration securityConfiguration=testSubject.createSecurityConfigurationFromRequest(reuqestMap,false);
assertTrue(securityConfiguration.getType() == SecurityType.KERBEROS);
}
InternalCallVerifier BooleanVerifier reuqestMap=new HashMap<>();
Map security=new HashMap<>();
security.put(SecurityConfigurationFactory.TYPE_PROPERTY_ID,SecurityType.NONE.toString());
reuqestMap.put(SecurityConfigurationFactory.SECURITY_PROPERTY_ID,security);
SecurityConfiguration securityConfiguration=testSubject.createSecurityConfigurationFromRequest(reuqestMap,false);
assertTrue(securityConfiguration.getType() == SecurityType.NONE);
}
InternalCallVerifier BooleanVerifier reuqestMap=new HashMap<>();
SecurityConfiguration securityConfiguration=testSubject.createSecurityConfigurationFromRequest(reuqestMap,false);
assertTrue(securityConfiguration == null);
}
InternalCallVerifier BooleanVerifier reuqestMap=new HashMap<>();
Map security=new HashMap<>();
security.put(SecurityConfigurationFactory.TYPE_PROPERTY_ID,SecurityType.KERBEROS.toString());
security.put(SecurityConfigurationFactory.KERBEROS_DESCRIPTOR_REFERENCE_PROPERTY_ID,TEST_KERBEROS_DESCRIPTOR_REFERENCE);
reuqestMap.put(SecurityConfigurationFactory.SECURITY_PROPERTY_ID,security);
EasyMock.replay(kerberosDescriptorDAO);
SecurityConfiguration securityConfiguration=testSubject.createSecurityConfigurationFromRequest(reuqestMap,false);
EasyMock.verify(kerberosDescriptorDAO);
assertTrue(securityConfiguration.getType() == SecurityType.KERBEROS);
}
InternalCallVerifier BooleanVerifier reuqestMap=new HashMap<>();
Map security=new HashMap<>();
security.put(SecurityConfigurationFactory.TYPE_PROPERTY_ID,SecurityType.KERBEROS.toString());
reuqestMap.put(SecurityConfigurationFactory.SECURITY_PROPERTY_ID,security);
SecurityConfiguration securityConfiguration=testSubject.createSecurityConfigurationFromRequest(reuqestMap,false);
assertTrue(securityConfiguration.getType() == SecurityType.KERBEROS);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier kdEntityCaptor=EasyMock.newCapture();
kerberosDescriptorDAO.create(capture(kdEntityCaptor));
EasyMock.replay(kerberosDescriptorDAO);
Map reuqestMap=new HashMap<>();
Map security=new HashMap<>();
security.put(SecurityConfigurationFactory.TYPE_PROPERTY_ID,SecurityType.KERBEROS.toString());
security.put(SecurityConfigurationFactory.KERBEROS_DESCRIPTOR_PROPERTY_ID,testKDReqPropertyMap());
reuqestMap.put(SecurityConfigurationFactory.SECURITY_PROPERTY_ID,security);
testSubject.createSecurityConfigurationFromRequest(reuqestMap,true);
EasyMock.verify(kerberosDescriptorDAO);
Assert.assertEquals("The persisted descriptortext is not as expected","{\"test\":\"{\\\"test\\\":\\\"test json\\\"}\"}",kdEntityCaptor.getValue().getKerberosDescriptorText());
Assert.assertNotNull("There is no generated kerberos descriptor reference in the persisting entity!",kdEntityCaptor.getValue().getName());
}
Class: org.apache.ambari.server.update.HostUpdateHelperTest InternalCallVerifier BooleanVerifier > hostChangesFileMap=hostUpdateHelper.getHostChangesFileMap();
Assert.assertTrue(hostChangesFileMap.get("cl1").containsKey("host1"));
Assert.assertTrue(hostChangesFileMap.get("cl1").containsKey("host2"));
Assert.assertTrue(hostChangesFileMap.get("cl1").get("host1").equals("host11"));
Assert.assertTrue(hostChangesFileMap.get("cl1").get("host2").equals("host22"));
}
Class: org.apache.ambari.server.upgrade.StackUpgradeUtilTest BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier entities=dao.findAll();
Assert.assertTrue(entities.size() > 0);
for ( MetainfoEntity entity : entities) {
Assert.assertTrue(entity.getMetainfoName().startsWith("repo:/HDP/1.3.0/"));
Assert.assertEquals(localRepoUrl,entity.getMetainfoValue());
}
reset(stackName,stackVersion);
entities=dao.findAll();
Assert.assertEquals(0,entities.size());
stackUpgradeUtil.updateLocalRepo(stackName,stackVersion,localRepoUrl,"centos6");
entities=dao.findAll();
for ( MetainfoEntity entity : entities) {
Assert.assertTrue(entity.getMetainfoName().startsWith("repo:/HDP/1.3.0/centos6") || entity.getMetainfoName().startsWith("repo:/HDP/1.3.0/redhat6"));
Assert.assertEquals(localRepoUrl,entity.getMetainfoValue());
}
reset(stackName,stackVersion);
entities=dao.findAll();
Assert.assertTrue(0 == entities.size());
stackUpgradeUtil.updateLocalRepo(stackName,stackVersion,localRepoUrl,"centos6,centos5");
entities=dao.findAll();
for ( MetainfoEntity entity : entities) {
Assert.assertTrue(entity.getMetainfoName().startsWith("repo:/HDP/1.3.0/centos6") || entity.getMetainfoName().startsWith("repo:/HDP/1.3.0/redhat6") || entity.getMetainfoName().startsWith("repo:/HDP/1.3.0/redhat5")|| entity.getMetainfoName().startsWith("repo:/HDP/1.3.0/centos5"));
Assert.assertEquals(localRepoUrl,entity.getMetainfoValue());
}
localRepoUrl="http://newfoo.bar";
stackUpgradeUtil.updateLocalRepo(stackName,stackVersion,localRepoUrl,"centos6");
entities=dao.findAll();
boolean foundCentos6=false;
boolean foundRedhat6=false;
for ( MetainfoEntity entity : entities) {
if (-1 != entity.getMetainfoName().indexOf("centos6")) {
foundCentos6=true;
Assert.assertEquals(localRepoUrl,entity.getMetainfoValue());
}
else if (-1 != entity.getMetainfoName().indexOf("redhat6")) {
foundRedhat6=true;
Assert.assertEquals(localRepoUrl,entity.getMetainfoValue());
}
else {
Assert.assertFalse(localRepoUrl.equals(entity.getMetainfoValue()));
}
}
Assert.assertTrue(foundCentos6);
Assert.assertTrue(foundRedhat6);
}
Class: org.apache.ambari.server.upgrade.UpgradeCatalog150Test InternalCallVerifier NullVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier TestInitializer InternalCallVerifier NullVerifier HybridVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.upgrade.UpgradeCatalog170Test BranchVerifier InternalCallVerifier EqualityVerifier clusterConfigAttributesColumnCapture=new Capture();
Capture hostgroupConfigAttributesColumnCapture=new Capture();
Capture blueprintConfigAttributesColumnCapture=new Capture();
Capture maskColumnCapture=new Capture();
Capture systemColumnCapture=new Capture();
Capture maskedColumnCapture=new Capture();
Capture stageCommandParamsColumnCapture=new Capture();
Capture stageHostParamsColumnCapture=new Capture();
Capture> groupsCapture=new Capture>();
Capture> alertDefinitionColumnCapture=new Capture>();
Capture> alertHistoryColumnCapture=new Capture>();
Capture> alertCurrentColumnCapture=new Capture>();
Capture> alertGroupColumnCapture=new Capture>();
Capture> alertTargetCapture=new Capture>();
Capture> alertGroupTargetCapture=new Capture>();
Capture> alertGroupingCapture=new Capture>();
Capture> alertNoticeCapture=new Capture>();
Capture> serviceConfigCapture=new Capture>();
Capture> serviceConfigMappingCapture=new Capture>();
Capture configDataClusterConfigCapture=new Capture();
Capture configDataBlueprintConfigurationCapture=new Capture();
Capture configDataHostGroupConfigurationCapture=new Capture();
dbAccessor.createTable(eq("groups"),capture(groupsCapture),eq("group_id"));
setViewExpectations(dbAccessor,maskColumnCapture,systemColumnCapture);
setViewParameterExpectations(dbAccessor,maskedColumnCapture);
setConfigAttributesColumnExpectations(dbAccessor,clusterConfigAttributesColumnCapture,"clusterconfig");
setConfigAttributesColumnExpectations(dbAccessor,hostgroupConfigAttributesColumnCapture,"hostgroup_configuration");
setConfigAttributesColumnExpectations(dbAccessor,blueprintConfigAttributesColumnCapture,"blueprint_configuration");
setStageExpectations(dbAccessor,stageCommandParamsColumnCapture,stageHostParamsColumnCapture);
dbAccessor.createTable(eq("alert_definition"),capture(alertDefinitionColumnCapture),eq("definition_id"));
dbAccessor.createTable(eq("alert_history"),capture(alertHistoryColumnCapture),eq("alert_id"));
dbAccessor.createTable(eq("alert_current"),capture(alertCurrentColumnCapture),eq("alert_id"));
dbAccessor.createTable(eq("alert_group"),capture(alertGroupColumnCapture),eq("group_id"));
dbAccessor.createTable(eq("alert_target"),capture(alertTargetCapture),eq("target_id"));
dbAccessor.createTable(eq("alert_group_target"),capture(alertGroupTargetCapture),eq("group_id"),eq("target_id"));
dbAccessor.createTable(eq("alert_grouping"),capture(alertGroupingCapture),eq("group_id"),eq("definition_id"));
dbAccessor.createTable(eq("alert_notice"),capture(alertNoticeCapture),eq("notification_id"));
dbAccessor.alterColumn(eq("clusterconfig"),capture(configDataClusterConfigCapture));
dbAccessor.alterColumn(eq("blueprint_configuration"),capture(configDataBlueprintConfigurationCapture));
dbAccessor.alterColumn(eq("hostgroup_configuration"),capture(configDataHostGroupConfigurationCapture));
dbAccessor.createTable(eq("serviceconfig"),capture(serviceConfigCapture),eq("service_config_id"));
dbAccessor.createTable(eq("serviceconfigmapping"),capture(serviceConfigMappingCapture),eq("service_config_id"),eq("config_id"));
dbAccessor.getConnection();
expectLastCall().andReturn(connection).anyTimes();
connection.createStatement();
expectLastCall().andReturn(statement).anyTimes();
statement.executeQuery(anyObject(String.class));
expectLastCall().andReturn(resultSet).anyTimes();
resultSet.next();
expectLastCall().andReturn(false).anyTimes();
resultSet.close();
expectLastCall().anyTimes();
replay(dbAccessor,configuration,resultSet,connection,stmt,statement);
AbstractUpgradeCatalog upgradeCatalog=getUpgradeCatalog(dbAccessor);
Class c=AbstractUpgradeCatalog.class;
Field f=c.getDeclaredField("configuration");
f.setAccessible(true);
f.set(upgradeCatalog,configuration);
upgradeCatalog.executeDDLUpdates();
verify(dbAccessor,configuration,resultSet,connection,stmt,statement);
assertClusterConfigColumns(clusterConfigAttributesColumnCapture);
assertHostgroupConfigColumns(hostgroupConfigAttributesColumnCapture);
assertBlueprintConfigColumns(blueprintConfigAttributesColumnCapture);
assertViewColumns(maskColumnCapture,systemColumnCapture);
assertViewParameterColumns(maskedColumnCapture);
assertStageColumns(stageCommandParamsColumnCapture,stageHostParamsColumnCapture);
assertEquals(4,groupsCapture.getValue().size());
List columnInfoList=groupsCapture.getValue();
for ( DBAccessor.DBColumnInfo info : columnInfoList) {
if (info.getName().equals("group_name")) {
assertEquals(Integer.valueOf(255),info.getLength());
break;
}
}
assertEquals(12,alertDefinitionColumnCapture.getValue().size());
assertEquals(11,alertHistoryColumnCapture.getValue().size());
assertEquals(7,alertCurrentColumnCapture.getValue().size());
assertEquals(5,alertGroupColumnCapture.getValue().size());
assertEquals(5,alertTargetCapture.getValue().size());
assertEquals(2,alertGroupTargetCapture.getValue().size());
assertEquals(2,alertGroupingCapture.getValue().size());
assertEquals(5,alertNoticeCapture.getValue().size());
assertEquals(2,serviceConfigCapture.getValue().size());
assertEquals(2,serviceConfigMappingCapture.getValue().size());
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier NullVerifier Class: org.apache.ambari.server.upgrade.UpgradeCatalog200Test InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier alertDefinitionIgnoreColumnCapture=new Capture();
Capture alertDefinitionDescriptionColumnCapture=new Capture();
Capture alertTargetGlobalColumnCapture=new Capture();
Capture hostComponentStateColumnCapture=new Capture();
Capture hostComponentVersionColumnCapture=new Capture();
Capture clustersSecurityTypeColumnCapture=new Capture();
Capture hostComponentStateSecurityStateColumnCapture=new Capture();
Capture hostComponentDesiredStateSecurityStateColumnCapture=new Capture();
Capture hostRoleCommandRetryColumnCapture=new Capture();
Capture stageSkippableColumnCapture=new Capture();
Capture viewparameterLabelColumnCapture=new Capture();
Capture viewparameterPlaceholderColumnCapture=new Capture();
Capture viewparameterDefaultValueColumnCapture=new Capture();
Capture serviceDesiredStateSecurityStateColumnCapture=new Capture();
Capture> clusterVersionCapture=new Capture>();
Capture> hostVersionCapture=new Capture>();
Capture valueColumnCapture=new Capture();
Capture dataValueColumnCapture=new Capture();
Capture> alertTargetStatesCapture=new Capture>();
Capture> artifactCapture=new Capture>();
Capture> kerberosPrincipalCapture=new Capture>();
Capture> kerberosPrincipalHostCapture=new Capture>();
Capture> upgradeCapture=new Capture>();
Capture> upgradeGroupCapture=new Capture>();
Capture> upgradeItemCapture=new Capture>();
dbAccessor.addColumn(eq("alert_definition"),capture(alertDefinitionIgnoreColumnCapture));
dbAccessor.addColumn(eq("alert_definition"),capture(alertDefinitionDescriptionColumnCapture));
dbAccessor.createTable(eq("alert_target_states"),capture(alertTargetStatesCapture));
dbAccessor.addColumn(eq("alert_target"),capture(alertTargetGlobalColumnCapture));
dbAccessor.addColumn(eq("hostcomponentstate"),capture(hostComponentStateColumnCapture));
dbAccessor.addColumn(eq("hostcomponentstate"),capture(hostComponentVersionColumnCapture));
dbAccessor.addColumn(eq("host_role_command"),capture(hostRoleCommandRetryColumnCapture));
dbAccessor.addColumn(eq("stage"),capture(stageSkippableColumnCapture));
dbAccessor.addColumn(eq("clusters"),capture(clustersSecurityTypeColumnCapture));
dbAccessor.addColumn(eq("hostcomponentstate"),capture(hostComponentStateSecurityStateColumnCapture));
dbAccessor.addColumn(eq("hostcomponentdesiredstate"),capture(hostComponentDesiredStateSecurityStateColumnCapture));
dbAccessor.addColumn(eq("viewparameter"),capture(viewparameterLabelColumnCapture));
dbAccessor.addColumn(eq("viewparameter"),capture(viewparameterPlaceholderColumnCapture));
dbAccessor.addColumn(eq("viewparameter"),capture(viewparameterDefaultValueColumnCapture));
dbAccessor.addColumn(eq("servicedesiredstate"),capture(serviceDesiredStateSecurityStateColumnCapture));
dbAccessor.createTable(eq("cluster_version"),capture(clusterVersionCapture),eq("id"));
dbAccessor.createTable(eq("host_version"),capture(hostVersionCapture),eq("id"));
dbAccessor.createTable(eq("upgrade"),capture(upgradeCapture),eq("upgrade_id"));
dbAccessor.createTable(eq("upgrade_group"),capture(upgradeGroupCapture),eq("upgrade_group_id"));
dbAccessor.createTable(eq("upgrade_item"),capture(upgradeItemCapture),eq("upgrade_item_id"));
dbAccessor.createTable(eq("artifact"),capture(artifactCapture),eq("artifact_name"),eq("foreign_keys"));
dbAccessor.createTable(eq("kerberos_principal"),capture(kerberosPrincipalCapture),eq("principal_name"));
dbAccessor.createTable(eq("kerberos_principal_host"),capture(kerberosPrincipalHostCapture),eq("principal_name"),eq("host_name"));
expect(dbAccessor.tableHasColumn("kerberos_principal_host","host_name")).andReturn(true).atLeastOnce();
dbAccessor.addFKConstraint(eq("kerberos_principal_host"),eq("FK_krb_pr_host_hostname"),eq("host_name"),eq("hosts"),eq("host_name"),eq(true),eq(false));
dbAccessor.addFKConstraint(eq("kerberos_principal_host"),eq("FK_krb_pr_host_principalname"),eq("principal_name"),eq("kerberos_principal"),eq("principal_name"),eq(true),eq(false));
setViewInstancePropertyExpectations(dbAccessor,valueColumnCapture);
setViewInstanceDataExpectations(dbAccessor,dataValueColumnCapture);
dbAccessor.getConnection();
expectLastCall().andReturn(connection).anyTimes();
connection.createStatement();
expectLastCall().andReturn(statement).anyTimes();
statement.executeQuery(anyObject(String.class));
expectLastCall().andReturn(resultSet).anyTimes();
replay(dbAccessor,configuration,resultSet,statement,connection);
AbstractUpgradeCatalog upgradeCatalog=getUpgradeCatalog(dbAccessor);
Class c=AbstractUpgradeCatalog.class;
Field f=c.getDeclaredField("configuration");
f.setAccessible(true);
f.set(upgradeCatalog,configuration);
upgradeCatalog.executeDDLUpdates();
verify(dbAccessor,configuration,resultSet,statement,connection);
verifyAlertDefinitionIgnoreColumn(alertDefinitionIgnoreColumnCapture);
verifyAlertDefinitionDescriptionColumn(alertDefinitionDescriptionColumnCapture);
verifyAlertTargetGlobal(alertTargetGlobalColumnCapture);
verifyAlertTargetStatesTable(alertTargetStatesCapture);
DBAccessor.DBColumnInfo upgradeStateColumn=hostComponentStateColumnCapture.getValue();
assertEquals("upgrade_state",upgradeStateColumn.getName());
assertEquals(32,(int)upgradeStateColumn.getLength());
assertEquals(String.class,upgradeStateColumn.getType());
assertEquals("NONE",upgradeStateColumn.getDefaultValue());
assertFalse(upgradeStateColumn.isNullable());
DBAccessor.DBColumnInfo upgradeVersionColumn=hostComponentVersionColumnCapture.getValue();
assertEquals("version",upgradeVersionColumn.getName());
assertEquals(32,(int)upgradeVersionColumn.getLength());
assertEquals(String.class,upgradeVersionColumn.getType());
assertEquals("UNKNOWN",upgradeVersionColumn.getDefaultValue());
assertFalse(upgradeVersionColumn.isNullable());
DBAccessor.DBColumnInfo upgradeRetryColumn=hostRoleCommandRetryColumnCapture.getValue();
assertEquals("retry_allowed",upgradeRetryColumn.getName());
assertEquals(1,(int)upgradeRetryColumn.getLength());
assertEquals(Integer.class,upgradeRetryColumn.getType());
assertEquals(0,upgradeRetryColumn.getDefaultValue());
assertFalse(upgradeRetryColumn.isNullable());
DBAccessor.DBColumnInfo upgradeSkippableColumn=stageSkippableColumnCapture.getValue();
assertEquals("skippable",upgradeSkippableColumn.getName());
assertEquals(1,(int)upgradeSkippableColumn.getLength());
assertEquals(Integer.class,upgradeSkippableColumn.getType());
assertEquals(0,upgradeSkippableColumn.getDefaultValue());
assertFalse(upgradeSkippableColumn.isNullable());
verifyClustersSecurityType(clustersSecurityTypeColumnCapture);
verifyComponentSecurityStateColumn(hostComponentStateSecurityStateColumnCapture);
verifyComponentSecurityStateColumn(hostComponentDesiredStateSecurityStateColumnCapture);
verifyServiceSecurityStateColumn(serviceDesiredStateSecurityStateColumnCapture);
verifyViewParameterColumns(viewparameterLabelColumnCapture,viewparameterPlaceholderColumnCapture,viewparameterDefaultValueColumnCapture);
List artifactColumns=artifactCapture.getValue();
testCreateArtifactTable(artifactColumns);
testCreateKerberosPrincipalTable(kerberosPrincipalCapture.getValue());
testCreateKerberosPrincipalHostTable(kerberosPrincipalHostCapture.getValue());
assertEquals(7,clusterVersionCapture.getValue().size());
assertEquals(4,hostVersionCapture.getValue().size());
assertViewInstancePropertyColumns(valueColumnCapture);
assertViewInstanceDataColumns(dataValueColumnCapture);
assertEquals(6,upgradeCapture.getValue().size());
assertEquals(4,upgradeGroupCapture.getValue().size());
assertEquals(7,upgradeItemCapture.getValue().size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier repos=new ArrayList(){
{
add(repositoryInfo1);
add(repositoryInfo2);
}
}
;
String output=UpgradeCatalog200.repositoryTable(repos);
assertEquals(" redhat6 | HDP-2.2 | http://public-repo-1.hortonworks.com/HDP/centos6/2.x/updates/2.2.6.0 \n" + " suse11 | HDP-UTILS-1.1.0.20 | http://public-repo-1.hortonworks.com/HDP-UTILS-1.1.0.20/repos/suse11sp3 \n",output);
}
InternalCallVerifier NullVerifier Class: org.apache.ambari.server.upgrade.UpgradeCatalog210Test APIUtilityVerifier InternalCallVerifier NullVerifier > updatedData=new Capture>();
ArtifactEntity artifactEntity=createNiceMock(ArtifactEntity.class);
expect(artifactEntity.getArtifactData()).andReturn(kerberosDescriptorOrig.toMap()).once();
artifactEntity.setArtifactData(capture(updatedData));
expectLastCall().once();
replay(artifactEntity,upgradeMock);
upgradeMock.updateKerberosDescriptorArtifact(createNiceMock(ArtifactDAO.class),artifactEntity);
verify(artifactEntity,upgradeMock);
KerberosDescriptor kerberosDescriptorUpdated=new KerberosDescriptorFactory().createInstance(updatedData.getValue());
assertNotNull(kerberosDescriptorUpdated);
assertNull(kerberosDescriptorUpdated.getIdentity("/hdfs"));
serviceDescriptor=kerberosDescriptorUpdated.getService("HDFS");
assertNotNull(serviceDescriptor);
assertNull(serviceDescriptor.getIdentity("/hdfs"));
assertNotNull(serviceDescriptor.getIdentity("hdfs"));
serviceDescriptor=kerberosDescriptorUpdated.getService("OOZIE");
assertNotNull(serviceDescriptor);
assertNull(serviceDescriptor.getIdentity("/hdfs"));
assertNotNull(serviceDescriptor.getIdentity("/HDFS/hdfs"));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier NullVerifier > updatedData=new Capture>();
ArtifactEntity artifactEntity=createNiceMock(ArtifactEntity.class);
expect(artifactEntity.getArtifactData()).andReturn(kerberosDescriptorOrig.toMap()).once();
artifactEntity.setArtifactData(capture(updatedData));
expectLastCall().once();
replay(artifactEntity,upgradeMock);
upgradeMock.updateKerberosDescriptorArtifact(createNiceMock(ArtifactDAO.class),artifactEntity);
verify(artifactEntity,upgradeMock);
KerberosDescriptor kerberosDescriptorUpdated=new KerberosDescriptorFactory().createInstance(updatedData.getValue());
assertNotNull(kerberosDescriptorUpdated);
assertNull(kerberosDescriptorUpdated.getIdentity("/hdfs"));
serviceDescriptor=kerberosDescriptorUpdated.getService("HDFS");
assertNotNull(serviceDescriptor);
assertNull(serviceDescriptor.getIdentity("/hdfs"));
assertNotNull(serviceDescriptor.getIdentity("hdfs"));
serviceDescriptor=kerberosDescriptorUpdated.getService("OOZIE");
assertNotNull(serviceDescriptor);
assertNull(serviceDescriptor.getIdentity("/hdfs"));
assertNotNull(serviceDescriptor.getIdentity("/HDFS/hdfs"));
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.upgrade.UpgradeCatalog211Test APIUtilityVerifier InternalCallVerifier EqualityVerifier entityManagerProvider=initEntityManagerProvider();
replayAll();
UpgradeCatalog upgradeCatalog=getUpgradeCatalog(dbAccessor,osFamily,entityManagerProvider.get());
Assert.assertEquals("2.1.1",upgradeCatalog.getTargetVersion());
verifyAll();
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier entityManagerProvider=initEntityManagerProvider();
replayAll();
UpgradeCatalog upgradeCatalog=getUpgradeCatalog(dbAccessor,osFamily,entityManagerProvider.get());
Assert.assertEquals("2.1.0",upgradeCatalog.getSourceVersion());
verifyAll();
}
InternalCallVerifier BooleanVerifier entityManagerProvider=initEntityManagerProvider();
final DBAccessor dbAccessor=createNiceMock(DBAccessor.class);
final OsFamily osFamily=createNiceMock(OsFamily.class);
Configuration configuration=createNiceMock(Configuration.class);
Connection connection=createNiceMock(Connection.class);
Statement statement=createNiceMock(Statement.class);
ResultSet resultSet=createNiceMock(ResultSet.class);
expect(configuration.getDatabaseUrl()).andReturn(Configuration.JDBC_IN_MEMORY_URL).anyTimes();
expect(configuration.getDatabaseType()).andReturn(DatabaseType.DERBY).anyTimes();
dbAccessor.getConnection();
expectLastCall().andReturn(connection).anyTimes();
connection.createStatement();
expectLastCall().andReturn(statement).anyTimes();
statement.executeQuery("SELECT COUNT(*) from ambari_sequences where sequence_name='hostcomponentstate_id_seq'");
expectLastCall().andReturn(resultSet).atLeastOnce();
ResultSet rs1=createNiceMock(ResultSet.class);
expect(rs1.next()).andReturn(Boolean.TRUE).once();
statement.executeQuery(anyObject(String.class));
expectLastCall().andReturn(rs1).anyTimes();
Capture queryCapture=new Capture();
dbAccessor.executeQuery(capture(queryCapture));
expectLastCall().once();
dbAccessor.setColumnNullable("viewinstanceproperty","value",true);
expectLastCall().once();
dbAccessor.setColumnNullable("viewinstancedata","value",true);
expectLastCall().once();
replayAll();
AbstractUpgradeCatalog upgradeCatalog=getUpgradeCatalog(dbAccessor,osFamily,entityManagerProvider.get());
Class c=AbstractUpgradeCatalog.class;
Field f=c.getDeclaredField("configuration");
f.setAccessible(true);
f.set(upgradeCatalog,configuration);
f=UpgradeCatalog211.class.getDeclaredField("m_hcsId");
f.setAccessible(true);
f.set(upgradeCatalog,new AtomicLong(1001));
upgradeCatalog.executeDDLUpdates();
verifyAll();
Assert.assertTrue(queryCapture.hasCaptured());
Assert.assertTrue(queryCapture.getValue().contains("1001"));
}
finally {
destroyInjector(injector);
}
}
BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier propertiesKerberosEnv=new HashMap(){
{
put("create_attributes_template","create_attributes_template content");
put("realm","EXAMPLE.COM");
put("container_dn","");
put("ldap_url","");
put("encryption_types","aes des3-cbc-sha1 rc4 des-cbc-md5");
put("kdc_host","c6407.ambari.apache.org");
put("admin_server_host","c6407.ambari.apache.org");
put("kdc_type","mit-kdc");
}
}
;
final Config configKerberosEnv=createNiceMock(Config.class);
expect(configKerberosEnv.getProperties()).andReturn(propertiesKerberosEnv).anyTimes();
expect(configKerberosEnv.getTag()).andReturn("tag1").anyTimes();
final Cluster cluster=createNiceMock(Cluster.class);
expect(cluster.getDesiredConfigByType("kerberos-env")).andReturn(configKerberosEnv).once();
final Injector injector=Guice.createInjector(new AbstractModule(){
@Override protected void configure(){
bind(AmbariManagementController.class).toInstance(controller);
bind(DBAccessor.class).toInstance(dbAccessor);
bind(OsFamily.class).toInstance(osFamily);
}
}
);
expect(cluster.getConfigsByType("kerberos-env")).andReturn(Collections.singletonMap("tag1",configKerberosEnv)).once();
expect(cluster.getDesiredConfigByType("kerberos-env")).andReturn(configKerberosEnv).once();
Capture captureCR=new Capture();
Capture clusterCapture=newCapture();
Capture typeCapture=newCapture();
Capture propertiesCapture=newCapture();
Capture tagCapture=newCapture();
Capture attributesCapture=newCapture();
expect(controller.createConfig(capture(clusterCapture),capture(typeCapture),capture(propertiesCapture),capture(tagCapture),capture(attributesCapture))).andReturn(createNiceMock(Config.class)).once();
replayAll();
injector.getInstance(UpgradeCatalog211.class).updateKerberosConfigurations(cluster);
verifyAll();
Map capturedCRProperties=propertiesCapture.getValue();
Assert.assertNotNull(capturedCRProperties);
Assert.assertFalse(capturedCRProperties.containsKey("create_attributes_template"));
Assert.assertTrue(capturedCRProperties.containsKey("ad_create_attributes_template"));
for ( String property : propertiesKerberosEnv.keySet()) {
if ("create_attributes_template".equals(property)) {
Assert.assertEquals("create_attributes_template/ad_create_attributes_template",propertiesKerberosEnv.get(property),capturedCRProperties.get("ad_create_attributes_template"));
}
else {
Assert.assertEquals(property,propertiesKerberosEnv.get(property),capturedCRProperties.get(property));
}
}
}
Class: org.apache.ambari.server.upgrade.UpgradeCatalog212Test InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier tableNameCaptor=newCapture();
Capture columnNameCaptor=newCapture();
expect(dbAccessor.tableHasColumn(capture(tableNameCaptor),capture(columnNameCaptor))).andReturn(true);
expect(statement.executeQuery(anyString())).andReturn(resultSet);
statement.close();
expect(resultSet.next()).andReturn(false);
resultSet.close();
replay(dbAccessor,connection,statement,resultSet);
testSubject.executePreDMLUpdates();
Assert.assertNotNull("The table name hasn't been captured",tableNameCaptor.getValue());
Assert.assertEquals("The table name is not as expected",TOPOLOGY_REQUEST_TABLE,tableNameCaptor.getValue());
Assert.assertNotNull("The column name hasn't been captured",columnNameCaptor.getValue());
Assert.assertEquals("The column name is not as expected",TOPOLOGY_REQUEST_CLUSTER_NAME_COLUMN,columnNameCaptor.getValue());
verify(dbAccessor,statement,resultSet);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier tableNameCaptor=newCapture();
Capture columnNameCaptor=newCapture();
expect(dbAccessor.tableHasColumn(capture(tableNameCaptor),capture(columnNameCaptor))).andReturn(false);
replay(dbAccessor);
testSubject.executePreDMLUpdates();
Assert.assertNotNull("The table name hasn't been captured",tableNameCaptor.getValue());
Assert.assertEquals("The table name is not as expected",TOPOLOGY_REQUEST_TABLE,tableNameCaptor.getValue());
Assert.assertNotNull("The column name hasn't been captured",columnNameCaptor.getValue());
Assert.assertEquals("The column name is not as expected",TOPOLOGY_REQUEST_CLUSTER_NAME_COLUMN,columnNameCaptor.getValue());
}
Class: org.apache.ambari.server.upgrade.UpgradeCatalog220Test InternalCallVerifier BooleanVerifier oldPropertiesAmsHbaseSite=new HashMap(){
{
put("zookeeper.session.timeout.localHBaseCluster",String.valueOf(20000));
}
}
;
Map newPropertiesAmsSite=new HashMap(){
{
put("zookeeper.session.timeout.localHBaseCluster",String.valueOf(120000));
put("hbase.normalizer.enabled",String.valueOf(true));
put("hbase.normalizer.period",String.valueOf(600000));
put("hbase.master.normalizer.class","org.apache.hadoop.hbase.master.normalizer.SimpleRegionNormalizer");
}
}
;
EasyMockSupport easyMockSupport=new EasyMockSupport();
Clusters clusters=easyMockSupport.createNiceMock(Clusters.class);
final Cluster cluster=easyMockSupport.createNiceMock(Cluster.class);
Config mockAmsHbaseSite=easyMockSupport.createNiceMock(Config.class);
expect(clusters.getClusters()).andReturn(new HashMap(){
{
put("normal",cluster);
}
}
).once();
expect(cluster.getDesiredConfigByType("ams-hbase-site")).andReturn(mockAmsHbaseSite).atLeastOnce();
expect(mockAmsHbaseSite.getProperties()).andReturn(oldPropertiesAmsHbaseSite).atLeastOnce();
Injector injector=easyMockSupport.createNiceMock(Injector.class);
expect(injector.getInstance(Gson.class)).andReturn(null).anyTimes();
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class)).anyTimes();
replay(injector,clusters,mockAmsHbaseSite,cluster);
AmbariManagementControllerImpl controller=createMockBuilder(AmbariManagementControllerImpl.class).addMockedMethod("createConfiguration").addMockedMethod("getClusters",new Class[]{}).addMockedMethod("createConfig").withConstructor(createNiceMock(ActionManager.class),clusters,injector).createNiceMock();
Injector injector2=easyMockSupport.createNiceMock(Injector.class);
Capture propertiesCapture=EasyMock.newCapture();
expect(injector2.getInstance(AmbariManagementController.class)).andReturn(controller).anyTimes();
expect(controller.getClusters()).andReturn(clusters).anyTimes();
expect(controller.createConfig(anyObject(Cluster.class),anyString(),capture(propertiesCapture),anyString(),anyObject(Map.class))).andReturn(createNiceMock(Config.class)).once();
replay(controller,injector2);
new UpgradeCatalog220(injector2).updateAMSConfigs();
easyMockSupport.verifyAll();
Map updatedProperties=propertiesCapture.getValue();
assertTrue(Maps.difference(newPropertiesAmsSite,updatedProperties).areEqual());
}
InternalCallVerifier BooleanVerifier oldPropertiesAmsSite=new HashMap(){
{
put("timeline.metrics.service.default.result.limit",String.valueOf(5760));
put("timeline.metrics.cluster.aggregator.minute.interval",String.valueOf(1000));
put("timeline.metrics.host.aggregator.minute.interval",String.valueOf(1000));
put("timeline.metrics.cluster.aggregator.minute.ttl",String.valueOf(1000));
}
}
;
Map newPropertiesAmsSite=new HashMap(){
{
put("timeline.metrics.service.default.result.limit",String.valueOf(15840));
put("timeline.metrics.cluster.aggregator.second.interval",String.valueOf(120));
put("timeline.metrics.cluster.aggregator.minute.interval",String.valueOf(300));
put("timeline.metrics.host.aggregator.minute.interval",String.valueOf(300));
put("timeline.metrics.cluster.aggregator.second.ttl",String.valueOf(2592000));
put("timeline.metrics.cluster.aggregator.minute.ttl",String.valueOf(7776000));
put("timeline.metrics.cluster.aggregator.second.checkpointCutOffMultiplier",String.valueOf(2));
put("timeline.metrics.cluster.aggregator.second.disabled",String.valueOf(false));
put("timeline.metrics.hbase.fifo.compaction.enabled",String.valueOf(true));
}
}
;
EasyMockSupport easyMockSupport=new EasyMockSupport();
Clusters clusters=easyMockSupport.createNiceMock(Clusters.class);
final Cluster cluster=easyMockSupport.createNiceMock(Cluster.class);
Config mockAmsSite=easyMockSupport.createNiceMock(Config.class);
expect(clusters.getClusters()).andReturn(new HashMap(){
{
put("normal",cluster);
}
}
).once();
expect(cluster.getDesiredConfigByType("ams-site")).andReturn(mockAmsSite).atLeastOnce();
expect(mockAmsSite.getProperties()).andReturn(oldPropertiesAmsSite).times(2);
Injector injector=easyMockSupport.createNiceMock(Injector.class);
expect(injector.getInstance(Gson.class)).andReturn(null).anyTimes();
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class)).anyTimes();
replay(injector,clusters,mockAmsSite,cluster);
AmbariManagementControllerImpl controller=createMockBuilder(AmbariManagementControllerImpl.class).addMockedMethod("createConfiguration").addMockedMethod("getClusters",new Class[]{}).addMockedMethod("createConfig").withConstructor(createNiceMock(ActionManager.class),clusters,injector).createNiceMock();
Injector injector2=easyMockSupport.createNiceMock(Injector.class);
Capture propertiesCapture=EasyMock.newCapture();
expect(injector2.getInstance(AmbariManagementController.class)).andReturn(controller).anyTimes();
expect(controller.getClusters()).andReturn(clusters).anyTimes();
expect(controller.createConfig(anyObject(Cluster.class),anyString(),capture(propertiesCapture),anyString(),anyObject(Map.class))).andReturn(createNiceMock(Config.class)).once();
replay(controller,injector2);
new UpgradeCatalog220(injector2).updateAMSConfigs();
easyMockSupport.verifyAll();
Map updatedProperties=propertiesCapture.getValue();
assertTrue(Maps.difference(newPropertiesAmsSite,updatedProperties).areEqual());
}
InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier NullVerifier > updatedData=new Capture>();
ArtifactEntity artifactEntity=createNiceMock(ArtifactEntity.class);
expect(artifactEntity.getArtifactData()).andReturn(kerberosDescriptorOrig.toMap()).once();
artifactEntity.setArtifactData(capture(updatedData));
expectLastCall().once();
replay(artifactEntity,upgradeMock);
upgradeMock.updateKerberosDescriptorArtifact(createNiceMock(ArtifactDAO.class),artifactEntity);
verify(artifactEntity,upgradeMock);
KerberosDescriptor kerberosDescriptorUpdated=new KerberosDescriptorFactory().createInstance(updatedData.getValue());
assertNotNull(kerberosDescriptorUpdated);
serviceDescriptor=kerberosDescriptorUpdated.getService("HDFS");
assertNotNull(serviceDescriptor);
assertNull(serviceDescriptor.getIdentity("hdfs"));
KerberosComponentDescriptor namenodeComponent=serviceDescriptor.getComponent("NAMENODE");
assertNotNull(namenodeComponent.getIdentity("hdfs"));
serviceDescriptor=kerberosDescriptorUpdated.getService("OOZIE");
assertNotNull(serviceDescriptor);
assertNull(serviceDescriptor.getIdentity("/HDFS/hdfs"));
assertNotNull(serviceDescriptor.getIdentity("/HDFS/NAMENODE/hdfs"));
}
Class: org.apache.ambari.server.upgrade.UpgradeCatalog221Test InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier oldPropertiesAmsHbaseSecuritySite=new HashMap(){
{
put("zookeeper.znode.parent","/ams-hbase-secure");
}
}
;
Map newPropertiesAmsHbaseSecuritySite=new HashMap(){
{
}
}
;
EasyMockSupport easyMockSupport=new EasyMockSupport();
Clusters clusters=easyMockSupport.createNiceMock(Clusters.class);
final Cluster cluster=easyMockSupport.createNiceMock(Cluster.class);
Config mockAmsHbaseSecuritySite=easyMockSupport.createNiceMock(Config.class);
expect(clusters.getClusters()).andReturn(new HashMap(){
{
put("normal",cluster);
}
}
).once();
expect(cluster.getDesiredConfigByType("ams-hbase-security-site")).andReturn(mockAmsHbaseSecuritySite).atLeastOnce();
expect(mockAmsHbaseSecuritySite.getProperties()).andReturn(oldPropertiesAmsHbaseSecuritySite).times(2);
Injector injector=easyMockSupport.createNiceMock(Injector.class);
expect(injector.getInstance(Gson.class)).andReturn(null).anyTimes();
expect(injector.getInstance(MaintenanceStateHelper.class)).andReturn(null).anyTimes();
expect(injector.getInstance(KerberosHelper.class)).andReturn(createNiceMock(KerberosHelper.class)).anyTimes();
replay(injector,clusters,mockAmsHbaseSecuritySite,cluster);
AmbariManagementControllerImpl controller=createMockBuilder(AmbariManagementControllerImpl.class).addMockedMethod("createConfiguration").addMockedMethod("getClusters",new Class[]{}).addMockedMethod("createConfig").withConstructor(createNiceMock(ActionManager.class),clusters,injector).createNiceMock();
Injector injector2=easyMockSupport.createNiceMock(Injector.class);
Capture propertiesCapture=EasyMock.newCapture();
expect(injector2.getInstance(AmbariManagementController.class)).andReturn(controller).anyTimes();
expect(controller.getClusters()).andReturn(clusters).anyTimes();
expect(controller.createConfig(anyObject(Cluster.class),anyString(),capture(propertiesCapture),anyString(),anyObject(Map.class))).andReturn(createNiceMock(Config.class)).once();
replay(controller,injector2);
new UpgradeCatalog221(injector2).updateAMSConfigs();
easyMockSupport.verifyAll();
Map updatedProperties=propertiesCapture.getValue();
assertTrue(Maps.difference(newPropertiesAmsHbaseSecuritySite,updatedProperties).areEqual());
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier capturedHostGroupComponentProvisionColumn=EasyMock.newCapture();
dbAccessor.addColumn(eq("hostgroup_component"),capture(capturedHostGroupComponentProvisionColumn));
expectLastCall().once();
replay(dbAccessor);
Module module=new Module(){
@Override public void configure( Binder binder){
binder.bind(DBAccessor.class).toInstance(dbAccessor);
binder.bind(OsFamily.class).toInstance(createNiceMock(OsFamily.class));
binder.bind(EntityManager.class).toInstance(entityManager);
}
}
;
Injector injector=Guice.createInjector(module);
UpgradeCatalog221 upgradeCatalog221=injector.getInstance(UpgradeCatalog221.class);
upgradeCatalog221.executeDDLUpdates();
assertEquals("Incorrect column name added","provision_action",capturedHostGroupComponentProvisionColumn.getValue().getName());
assertNull("Incorrect default value added",capturedHostGroupComponentProvisionColumn.getValue().getDefaultValue());
assertEquals("Incorrect column type added",String.class,capturedHostGroupComponentProvisionColumn.getValue().getType());
assertEquals("Incorrect column length added",255,capturedHostGroupComponentProvisionColumn.getValue().getLength().intValue());
assertTrue("Incorrect column nullable state added",capturedHostGroupComponentProvisionColumn.getValue().isNullable());
verify(dbAccessor);
}
Class: org.apache.ambari.server.upgrade.UpgradeCatalog230Test InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier columnCapture=EasyMock.newCapture();
Capture columnCapturePermissionLabel=EasyMock.newCapture();
Capture> columnsCaptureRoleAuthorization=EasyMock.newCapture();
Capture> columnsCapturePermissionRoleAuthorization=EasyMock.newCapture();
dbAccessor.alterColumn(eq("host_role_command"),capture(columnCapture));
expectLastCall();
dbAccessor.addColumn(eq("adminpermission"),capture(columnCapturePermissionLabel));
expectLastCall();
dbAccessor.createTable(eq("roleauthorization"),capture(columnsCaptureRoleAuthorization),eq("authorization_id"));
expectLastCall();
dbAccessor.createTable(eq("permission_roleauthorization"),capture(columnsCapturePermissionRoleAuthorization),eq("permission_id"),eq("authorization_id"));
expectLastCall();
dbAccessor.addFKConstraint("permission_roleauthorization","FK_permission_roleauth_pid","permission_id","adminpermission","permission_id",false);
expectLastCall();
dbAccessor.addFKConstraint("permission_roleauthorization","FK_permission_roleauth_aid","authorization_id","roleauthorization","authorization_id",false);
expectLastCall();
replayAll();
AbstractUpgradeCatalog upgradeCatalog=injector.getInstance(UpgradeCatalog230.class);
Class c=AbstractUpgradeCatalog.class;
Field f=c.getDeclaredField("configuration");
f.setAccessible(true);
f.set(upgradeCatalog,configuration);
upgradeCatalog.executeDDLUpdates();
verifyAll();
assertTrue(columnCapture.getValue().isNullable());
assertEquals(columnCapturePermissionLabel.getValue().getName(),"permission_label");
assertEquals(columnCapturePermissionLabel.getValue().getType(),String.class);
assertEquals(columnCapturePermissionLabel.getValue().getLength(),Integer.valueOf(255));
assertEquals(columnCapturePermissionLabel.getValue().isNullable(),true);
List columnInfos;
DBAccessor.DBColumnInfo columnInfo;
columnInfos=columnsCaptureRoleAuthorization.getValue();
assertEquals(2,columnInfos.size());
columnInfo=columnInfos.get(0);
assertEquals("authorization_id",columnInfo.getName());
assertEquals(String.class,columnInfo.getType());
assertEquals(Integer.valueOf(100),columnInfo.getLength());
columnInfo=columnInfos.get(1);
assertEquals("authorization_name",columnInfo.getName());
assertEquals(String.class,columnInfo.getType());
assertEquals(Integer.valueOf(255),columnInfo.getLength());
columnInfos=columnsCapturePermissionRoleAuthorization.getValue();
assertEquals(2,columnInfos.size());
columnInfo=columnInfos.get(0);
assertEquals("permission_id",columnInfo.getName());
assertEquals(Long.class,columnInfo.getType());
assertEquals(null,columnInfo.getLength());
columnInfo=columnInfos.get(1);
assertEquals("authorization_id",columnInfo.getName());
assertEquals(String.class,columnInfo.getType());
assertEquals(Integer.valueOf(100),columnInfo.getLength());
}
InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.upgrade.UpgradeCatalog240Test InternalCallVerifier EqualityVerifier params=Arrays.asList("connection.timeout","checkpoint.time.warning.threshold","checkpoint.time.critical.threshold");
String expectedSource="{\"path\":\"test_path\",\"type\":\"SCRIPT\",\"parameters\":[{\"name\":\"connection.timeout\",\"display_name\":\"Connection Timeout\",\"value\":5.0,\"type\":\"NUMERIC\",\"description\":\"The maximum time before this alert is considered to be CRITICAL\",\"units\":\"seconds\",\"threshold\":\"CRITICAL\"},{\"name\":\"checkpoint.time.warning.threshold\",\"display_name\":\"Checkpoint Warning\",\"value\":2.0,\"type\":\"PERCENT\",\"description\":\"The percentage of the last checkpoint time greater than the interval in order to trigger a warning alert.\",\"units\":\"%\",\"threshold\":\"WARNING\"},{\"name\":\"checkpoint.time.critical.threshold\",\"display_name\":\"Checkpoint Critical\",\"value\":2.0,\"type\":\"PERCENT\",\"description\":\"The percentage of the last checkpoint time greater than the interval in order to trigger a critical alert.\",\"units\":\"%\",\"threshold\":\"CRITICAL\"}]}";
String result=upgradeCatalog240.addParam(inputSource,params);
Assert.assertEquals(result,expectedSource);
}
InternalCallVerifier EqualityVerifier params=new ArrayList(Arrays.asList("connection.timeout","checkpoint.time.warning.threshold","checkpoint.time.critical.threshold"));
String expectedSource="{\"path\":\"test_path\",\"type\":\"SCRIPT\",\"parameters\":[{\"name\":\"connection.timeout\",\"display_name\":\"Connection Timeout\",\"value\":5.0,\"type\":\"NUMERIC\",\"description\":\"The maximum time before this alert is considered to be CRITICAL\",\"units\":\"seconds\",\"threshold\":\"CRITICAL\"},{\"name\":\"checkpoint.time.warning.threshold\",\"display_name\":\"Checkpoint Warning\",\"value\":2.0,\"type\":\"PERCENT\",\"description\":\"The percentage of the last checkpoint time greater than the interval in order to trigger a warning alert.\",\"units\":\"%\",\"threshold\":\"WARNING\"},{\"name\":\"checkpoint.time.critical.threshold\",\"display_name\":\"Checkpoint Critical\",\"value\":2.0,\"type\":\"PERCENT\",\"description\":\"The percentage of the last checkpoint time greater than the interval in order to trigger a critical alert.\",\"units\":\"%\",\"threshold\":\"CRITICAL\"}]}";
String result=upgradeCatalog240.addParam(inputSource,params);
Assert.assertEquals(result,expectedSource);
}
Class: org.apache.ambari.server.upgrade.UpgradeCatalogTest InternalCallVerifier BooleanVerifier IdentityVerifier EqualityVerifier NullVerifier HybridVerifier properties=new HashMap(){
{
put("a","b");
}
}
;
final ClusterRequest cl=new ClusterRequest(cluster.getClusterId(),cluster.getClusterName(),cluster.getDesiredStackVersion().getStackVersion(),null);
ConfigurationRequest cr=new ConfigurationRequest();
cr.setClusterName(cluster.getClusterName());
cr.setType("global");
cr.setVersionTag("version1");
cr.setProperties(properties);
cl.setDesiredConfig(Collections.singletonList(cr));
controller.updateClusters(new HashSet(){
{
add(cl);
}
}
,null);
Config config=cluster.getConfig("global","version1");
Assert.assertNotNull(config);
Assert.assertEquals(properties,config.getProperties());
UpgradeCatalog149 testCatalog=injector.getInstance(UpgradeCatalog149.class);
testCatalog.updateConfigurationProperties("global",Collections.singletonMap("x","y"),false,false);
config=cluster.getDesiredConfigByType("global");
String version=config.getTag();
Assert.assertNotNull(config);
Assert.assertNotSame("version1",version);
Assert.assertTrue(config.getProperties().containsKey("x"));
Assert.assertEquals("y",config.getProperties().get("x"));
testCatalog.updateConfigurationProperties("global",Collections.singletonMap("x","z"),true,false);
config=cluster.getDesiredConfigByType("global");
Assert.assertNotNull(config);
Assert.assertNotSame(version,config.getTag());
Assert.assertTrue(config.getProperties().containsKey("x"));
Assert.assertEquals("z",config.getProperties().get("x"));
version=config.getTag();
testCatalog.updateConfigurationProperties("global",Collections.singletonMap("x","y"),false,false);
config=cluster.getDesiredConfigByType("global");
Assert.assertNotNull(config);
Assert.assertSame(version,config.getTag());
Assert.assertTrue(config.getProperties().containsKey("x"));
Assert.assertEquals("z",config.getProperties().get("x"));
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier upgradeCatalogSet=schemaUpgradeHelper.getAllUpgradeCatalogs();
Assert.assertNotNull(upgradeCatalogSet);
Assert.assertEquals(5,upgradeCatalogSet.size());
List upgradeCatalogs=schemaUpgradeHelper.getUpgradePath(null,"1.5.1");
Assert.assertNotNull(upgradeCatalogs);
Assert.assertEquals(2,upgradeCatalogs.size());
Assert.assertEquals("1.4.9",upgradeCatalogs.get(0).getTargetVersion());
Assert.assertEquals("1.5.0",upgradeCatalogs.get(1).getTargetVersion());
}
Class: org.apache.ambari.server.utils.StageUtilsTest InternalCallVerifier EqualityVerifier wrappers=s.getExecutionCommands(hostname);
for ( ExecutionCommandWrapper wrapper : wrappers) {
assertEquals("cluster1",wrapper.getExecutionCommand().getClusterName());
assertEquals(StageUtils.getActionId(1,2),wrapper.getExecutionCommand().getCommandId());
assertEquals(hostname,wrapper.getExecutionCommand().getHostname());
}
}
InternalCallVerifier EqualityVerifier wrappers=s.getExecutionCommands(hostname);
for ( ExecutionCommandWrapper wrapper : wrappers) {
}
assertEquals(StageUtils.getActionId(1,2),s.getActionId());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier > configTags=new HashMap>();
Map globalTag=new HashMap();
globalTag.put("tag","version1");
configTags.put("global",globalTag);
cmd.setConfigurationTags(configTags);
String json=StageUtils.jaxbToString(cmd);
InputStream is=new ByteArrayInputStream(json.getBytes(Charset.forName("UTF8")));
ExecutionCommand cmdDes=new Gson().fromJson(new InputStreamReader(is),ExecutionCommand.class);
assertEquals(cmd.toString(),cmdDes.toString());
assertEquals(cmd,cmdDes);
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier hostAttributes=new HashMap(){
{
put("os_family","redhat");
put("os_release_version","5.9");
}
}
;
final Clusters clusters=createNiceMock(Clusters.class);
List hosts=new ArrayList();
List hostNames=new ArrayList();
List pingPorts=Arrays.asList(StageUtils.DEFAULT_PING_PORT,StageUtils.DEFAULT_PING_PORT,StageUtils.DEFAULT_PING_PORT,8671,8671,null,8672,8672,null,8673);
for (int i=0; i < 10; i++) {
String hostname=String.format("h%d",i);
Host host=createNiceMock(Host.class);
expect(host.getHostName()).andReturn(hostname).anyTimes();
expect(host.getHostAttributes()).andReturn(hostAttributes).anyTimes();
expect(host.getCurrentPingPort()).andReturn(pingPorts.get(i)).anyTimes();
hosts.add(host);
hostNames.add(hostname);
expect(clusters.getHost(hostname)).andReturn(host).anyTimes();
}
final ServiceComponentHost nnh0ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(nnh0ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost snnh1ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(snnh1ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost dnh0ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(dnh0ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost dnh1ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(dnh1ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost dnh2ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(dnh2ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost dnh3ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(dnh3ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost dnh5ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(dnh5ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost dnh7ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(dnh7ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost dnh8ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(dnh8ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost dnh9ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(dnh9ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost hbm5ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(hbm5ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost hbrs1ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(hbrs1ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost hbrs3ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(hbrs3ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost hbrs5ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(hbrs5ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost hbrs8ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(hbrs8ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost hbrs9ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(hbrs9ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost mrjt5ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(mrjt5ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost mrtt1ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(mrtt1ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost mrtt2ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(mrtt2ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.DECOMMISSIONED).anyTimes();
final ServiceComponentHost mrtt3ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(mrtt3ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.DECOMMISSIONED).anyTimes();
final ServiceComponentHost mrtt4ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(mrtt4ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost mrtt5ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(mrtt5ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost mrtt7ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(mrtt7ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost mrtt9ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(mrtt9ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
final ServiceComponentHost nns7ServiceComponentHost=createMock(ServiceComponentHost.class);
expect(nns7ServiceComponentHost.getComponentAdminState()).andReturn(HostComponentAdminState.INSERVICE).anyTimes();
Map> projectedTopology=new HashMap>();
final HashMap nnServiceComponentHosts=new HashMap(){
{
put("h0",nnh0ServiceComponentHost);
}
}
;
insertTopology(projectedTopology,"NAMENODE",nnServiceComponentHosts.keySet());
final HashMap snnServiceComponentHosts=new HashMap(){
{
put("h1",snnh1ServiceComponentHost);
}
}
;
insertTopology(projectedTopology,"SECONDARY_NAMENODE",snnServiceComponentHosts.keySet());
final Map dnServiceComponentHosts=new HashMap(){
{
put("h0",dnh0ServiceComponentHost);
put("h1",dnh1ServiceComponentHost);
put("h2",dnh2ServiceComponentHost);
put("h3",dnh3ServiceComponentHost);
put("h5",dnh5ServiceComponentHost);
put("h7",dnh7ServiceComponentHost);
put("h8",dnh8ServiceComponentHost);
put("h9",dnh9ServiceComponentHost);
}
}
;
insertTopology(projectedTopology,"DATANODE",dnServiceComponentHosts.keySet());
final Map hbmServiceComponentHosts=new HashMap(){
{
put("h5",hbm5ServiceComponentHost);
}
}
;
insertTopology(projectedTopology,"HBASE_MASTER",hbmServiceComponentHosts.keySet());
final Map hbrsServiceComponentHosts=new HashMap(){
{
put("h1",hbrs1ServiceComponentHost);
put("h3",hbrs3ServiceComponentHost);
put("h5",hbrs5ServiceComponentHost);
put("h8",hbrs8ServiceComponentHost);
put("h9",hbrs9ServiceComponentHost);
}
}
;
insertTopology(projectedTopology,"HBASE_REGIONSERVER",hbrsServiceComponentHosts.keySet());
final Map mrjtServiceComponentHosts=new HashMap(){
{
put("h5",mrjt5ServiceComponentHost);
}
}
;
insertTopology(projectedTopology,"JOBTRACKER",mrjtServiceComponentHosts.keySet());
final Map mrttServiceComponentHosts=new HashMap(){
{
put("h1",mrtt1ServiceComponentHost);
put("h2",mrtt2ServiceComponentHost);
put("h3",mrtt3ServiceComponentHost);
put("h4",mrtt4ServiceComponentHost);
put("h5",mrtt5ServiceComponentHost);
put("h7",mrtt7ServiceComponentHost);
put("h9",mrtt9ServiceComponentHost);
}
}
;
insertTopology(projectedTopology,"TASKTRACKER",mrttServiceComponentHosts.keySet());
final Map nnsServiceComponentHosts=new HashMap(){
{
put("h7",nns7ServiceComponentHost);
}
}
;
insertTopology(projectedTopology,"NONAME_SERVER",nnsServiceComponentHosts.keySet());
final ServiceComponent nnComponent=createMock(ServiceComponent.class);
expect(nnComponent.getName()).andReturn("NAMENODE").anyTimes();
expect(nnComponent.getServiceComponentHost(anyObject(String.class))).andAnswer(new IAnswer(){
@Override public ServiceComponentHost answer() throws Throwable {
Object[] args=getCurrentArguments();
return nnServiceComponentHosts.get((String)args[0]);
}
}
).anyTimes();
expect(nnComponent.getServiceComponentHosts()).andReturn(nnServiceComponentHosts).anyTimes();
expect(nnComponent.isClientComponent()).andReturn(false).anyTimes();
final ServiceComponent snnComponent=createMock(ServiceComponent.class);
expect(snnComponent.getName()).andReturn("SECONDARY_NAMENODE").anyTimes();
expect(snnComponent.getServiceComponentHost(anyObject(String.class))).andAnswer(new IAnswer(){
@Override public ServiceComponentHost answer() throws Throwable {
Object[] args=getCurrentArguments();
return snnServiceComponentHosts.get((String)args[0]);
}
}
).anyTimes();
expect(snnComponent.getServiceComponentHosts()).andReturn(snnServiceComponentHosts).anyTimes();
expect(snnComponent.isClientComponent()).andReturn(false).anyTimes();
final ServiceComponent dnComponent=createMock(ServiceComponent.class);
expect(dnComponent.getName()).andReturn("DATANODE").anyTimes();
expect(dnComponent.getServiceComponentHost(anyObject(String.class))).andAnswer(new IAnswer(){
@Override public ServiceComponentHost answer() throws Throwable {
Object[] args=getCurrentArguments();
return dnServiceComponentHosts.get((String)args[0]);
}
}
).anyTimes();
expect(dnComponent.getServiceComponentHosts()).andReturn(dnServiceComponentHosts).anyTimes();
expect(dnComponent.isClientComponent()).andReturn(false).anyTimes();
final ServiceComponent hbmComponent=createMock(ServiceComponent.class);
expect(hbmComponent.getName()).andReturn("HBASE_MASTER").anyTimes();
expect(hbmComponent.getServiceComponentHost(anyObject(String.class))).andAnswer(new IAnswer(){
@Override public ServiceComponentHost answer() throws Throwable {
Object[] args=getCurrentArguments();
return hbmServiceComponentHosts.get((String)args[0]);
}
}
).anyTimes();
expect(hbmComponent.getServiceComponentHosts()).andReturn(hbmServiceComponentHosts).anyTimes();
expect(hbmComponent.isClientComponent()).andReturn(false).anyTimes();
final ServiceComponent hbrsComponent=createMock(ServiceComponent.class);
expect(hbrsComponent.getName()).andReturn("HBASE_REGIONSERVER").anyTimes();
expect(hbrsComponent.getServiceComponentHost(anyObject(String.class))).andAnswer(new IAnswer(){
@Override public ServiceComponentHost answer() throws Throwable {
Object[] args=getCurrentArguments();
return hbrsServiceComponentHosts.get((String)args[0]);
}
}
).anyTimes();
Map hbrsHosts=Maps.filterKeys(hbrsServiceComponentHosts,new Predicate(){
@Override public boolean apply( String s){
return s.equals("h1");
}
}
);
expect(hbrsComponent.getServiceComponentHosts()).andReturn(hbrsServiceComponentHosts).anyTimes();
expect(hbrsComponent.isClientComponent()).andReturn(false).anyTimes();
final ServiceComponent mrjtComponent=createMock(ServiceComponent.class);
expect(mrjtComponent.getName()).andReturn("JOBTRACKER").anyTimes();
expect(mrjtComponent.getServiceComponentHost(anyObject(String.class))).andAnswer(new IAnswer(){
@Override public ServiceComponentHost answer() throws Throwable {
Object[] args=getCurrentArguments();
return mrjtServiceComponentHosts.get((String)args[0]);
}
}
).anyTimes();
expect(mrjtComponent.getServiceComponentHosts()).andReturn(mrjtServiceComponentHosts).anyTimes();
expect(mrjtComponent.isClientComponent()).andReturn(false).anyTimes();
final ServiceComponent mrttCompomnent=createMock(ServiceComponent.class);
expect(mrttCompomnent.getName()).andReturn("TASKTRACKER").anyTimes();
expect(mrttCompomnent.getServiceComponentHost(anyObject(String.class))).andAnswer(new IAnswer(){
@Override public ServiceComponentHost answer() throws Throwable {
Object[] args=getCurrentArguments();
return mrttServiceComponentHosts.get((String)args[0]);
}
}
).anyTimes();
expect(mrttCompomnent.getServiceComponentHosts()).andReturn(mrttServiceComponentHosts).anyTimes();
expect(mrttCompomnent.isClientComponent()).andReturn(false).anyTimes();
final ServiceComponent nnsComponent=createMock(ServiceComponent.class);
expect(nnsComponent.getName()).andReturn("NONAME_SERVER").anyTimes();
expect(nnsComponent.getServiceComponentHost(anyObject(String.class))).andAnswer(new IAnswer(){
@Override public ServiceComponentHost answer() throws Throwable {
Object[] args=getCurrentArguments();
return nnsServiceComponentHosts.get((String)args[0]);
}
}
).anyTimes();
expect(nnsComponent.getServiceComponentHosts()).andReturn(nnsServiceComponentHosts).anyTimes();
expect(nnsComponent.isClientComponent()).andReturn(false).anyTimes();
final Service hdfsService=createMock(Service.class);
expect(hdfsService.getServiceComponents()).andReturn(new HashMap(){
{
put("NAMENODE",nnComponent);
put("SECONDARY_NAMENODE",snnComponent);
put("DATANODE",dnComponent);
}
}
).anyTimes();
final Service hbaseService=createMock(Service.class);
expect(hbaseService.getServiceComponents()).andReturn(new HashMap(){
{
put("HBASE_MASTER",hbmComponent);
put("HBASE_REGIONSERVER",hbrsComponent);
}
}
).anyTimes();
final Service mrService=createMock(Service.class);
expect(mrService.getServiceComponents()).andReturn(new HashMap(){
{
put("JOBTRACKER",mrjtComponent);
put("TASKTRACKER",mrttCompomnent);
}
}
).anyTimes();
final Service nnService=createMock(Service.class);
expect(nnService.getServiceComponents()).andReturn(new HashMap(){
{
put("NONAME_SERVER",nnsComponent);
}
}
).anyTimes();
Cluster cluster=createMock(Cluster.class);
expect(cluster.getHosts()).andReturn(hosts).anyTimes();
expect(cluster.getServices()).andReturn(new HashMap(){
{
put("HDFS",hdfsService);
put("HBASE",hbaseService);
put("MAPREDUCE",mrService);
put("NONAME",nnService);
}
}
).anyTimes();
final TopologyManager topologyManager=injector.getInstance(TopologyManager.class);
topologyManager.getPendingHostComponents();
expectLastCall().andReturn(projectedTopology).once();
replayAll();
injector.getInstance(AmbariMetaInfo.class).init();
Map> info=StageUtils.getClusterHostInfo(cluster);
verifyAll();
Set allHosts=info.get(StageUtils.HOSTS_LIST);
assertEquals(hosts.size(),allHosts.size());
for ( Host host : hosts) {
assertTrue(allHosts.contains(host.getHostName()));
}
checkServiceHostIndexes(info,"DATANODE","slave_hosts",projectedTopology,hostNames);
checkServiceHostIndexes(info,"NAMENODE","namenode_host",projectedTopology,hostNames);
checkServiceHostIndexes(info,"SECONDARY_NAMENODE","snamenode_host",projectedTopology,hostNames);
checkServiceHostIndexes(info,"HBASE_MASTER","hbase_master_hosts",projectedTopology,hostNames);
checkServiceHostIndexes(info,"HBASE_REGIONSERVER","hbase_rs_hosts",projectedTopology,hostNames);
checkServiceHostIndexes(info,"JOBTRACKER","jtnode_host",projectedTopology,hostNames);
checkServiceHostIndexes(info,"TASKTRACKER","mapred_tt_hosts",projectedTopology,hostNames);
checkServiceHostIndexes(info,"NONAME_SERVER","noname_server_hosts",projectedTopology,hostNames);
Set actualPingPorts=info.get(StageUtils.PORTS);
if (pingPorts.contains(null)) {
assertEquals(new HashSet(pingPorts).size(),actualPingPorts.size() + 1);
}
else {
assertEquals(new HashSet(pingPorts).size(),actualPingPorts.size());
}
List pingPortsActual=getRangeMappedDecompressedSet(actualPingPorts);
List reindexedPorts=getReindexedList(pingPortsActual,new ArrayList(allHosts),hostNames);
List expectedPingPorts=new ArrayList(pingPorts);
for (int i=0; i < expectedPingPorts.size(); i++) {
if (expectedPingPorts.get(i) == null) {
expectedPingPorts.set(i,StageUtils.DEFAULT_PING_PORT);
}
}
assertEquals(expectedPingPorts,reindexedPorts);
assertTrue(info.containsKey("decom_tt_hosts"));
Set decommissionedHosts=info.get("decom_tt_hosts");
assertEquals(2,decommissionedHosts.toString().split(",").length);
assertTrue(info.containsKey(StageUtils.AMBARI_SERVER_HOST));
Set serverHost=info.get(StageUtils.AMBARI_SERVER_HOST);
assertEquals(1,serverHost.size());
assertEquals(StageUtils.getHostName(),serverHost.iterator().next());
assertTrue(getDecompressedSet(info.get("hbase_rs_hosts")).contains(9));
info=StageUtils.substituteHostIndexes(info);
checkServiceHostNames(info,"DATANODE","slave_hosts",projectedTopology);
checkServiceHostNames(info,"NAMENODE","namenode_host",projectedTopology);
checkServiceHostNames(info,"SECONDARY_NAMENODE","snamenode_host",projectedTopology);
checkServiceHostNames(info,"HBASE_MASTER","hbase_master_hosts",projectedTopology);
checkServiceHostNames(info,"HBASE_REGIONSERVER","hbase_rs_hosts",projectedTopology);
checkServiceHostNames(info,"JOBTRACKER","jtnode_host",projectedTopology);
checkServiceHostNames(info,"TASKTRACKER","mapred_tt_hosts",projectedTopology);
checkServiceHostNames(info,"NONAME_SERVER","noname_server_hosts",projectedTopology);
}
Class: org.apache.ambari.server.utils.TestParallel APIUtilityVerifier IterativeVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier input=new LinkedList();
for (int i=0; i < 10; i++) {
input.add(i);
}
final List failForList=Arrays.asList(new Integer[]{2,5,7});
ParallelLoopResult loopResult=Parallel.forLoop(input,new LoopBody(){
@Override public Integer run( Integer in1){
if (failForList.contains(in1)) {
throw new RuntimeException("Ignore this exception");
}
return in1 * in1;
}
}
);
Assert.assertFalse(loopResult.getIsCompleted());
Assert.assertNotNull(loopResult.getResult());
List output=loopResult.getResult();
Assert.assertEquals(input.size(),output.size());
for (int i=0; i < input.size(); i++) {
if (failForList.contains(i)) {
Assert.assertNull(output.get(i));
output.set(i,i * i);
}
else {
Assert.assertEquals(i * i,(int)output.get(i));
}
}
}
APIUtilityVerifier IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier input=new LinkedList();
for (int i=0; i < 10; i++) {
input.add(i);
}
final ParallelLoopResult[] innerLoopResults=new ParallelLoopResult[input.size()];
ParallelLoopResult loopResult=Parallel.forLoop(input,new LoopBody(){
@Override public Integer run( final Integer in1){
int sq=in1 * in1;
ParallelLoopResult innerLoopResult=Parallel.forLoop(input,new LoopBody(){
@Override public Integer run( Integer in2){
return in1 * in2;
}
}
);
innerLoopResults[in1]=innerLoopResult;
return in1 * in1;
}
}
);
Assert.assertNotNull(loopResult);
Assert.assertTrue(loopResult.getIsCompleted());
List output=loopResult.getResult();
Assert.assertNotNull(output);
Assert.assertEquals(input.size(),output.size());
for (int i=0; i < input.size(); i++) {
Assert.assertEquals(i * i,(int)output.get(i));
ParallelLoopResult innerLoopResult=innerLoopResults[i];
Assert.assertNotNull(innerLoopResult);
Assert.assertTrue(innerLoopResult.getIsCompleted());
List innerOutput=innerLoopResult.getResult();
Assert.assertNotNull(innerOutput);
Assert.assertEquals(input.size(),innerOutput.size());
for (int j=0; j < input.size(); j++) {
Assert.assertEquals(i * j,(int)innerOutput.get(j));
}
}
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier nullLoopResult=Parallel.forLoop(null,new LoopBody(){
@Override public Integer run( Integer integer){
return integer;
}
}
);
Assert.assertTrue(nullLoopResult.getIsCompleted());
Assert.assertTrue(nullLoopResult.getResult().isEmpty());
ParallelLoopResult emptyLoopResult=Parallel.forLoop(new ArrayList(),new LoopBody(){
@Override public Integer run( Integer integer){
return integer;
}
}
);
Assert.assertTrue(emptyLoopResult.getIsCompleted());
Assert.assertTrue(emptyLoopResult.getResult().isEmpty());
ParallelLoopResult singleElementLoopResult=Parallel.forLoop(Collections.singletonList(7),new LoopBody(){
@Override public Integer run( Integer integer){
return integer;
}
}
);
Assert.assertTrue(singleElementLoopResult.getIsCompleted());
List singleElementList=singleElementLoopResult.getResult();
Assert.assertTrue(singleElementLoopResult.getIsCompleted());
Assert.assertFalse(singleElementList.isEmpty());
Assert.assertEquals(1,singleElementList.size());
Assert.assertNotNull(singleElementList.get(0));
}
APIUtilityVerifier IterativeVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier input=new LinkedList();
for (int i=0; i < 10; i++) {
input.add(i);
}
ParallelLoopResult loopResult=Parallel.forLoop(input,new LoopBody(){
@Override public Integer run( Integer in1){
return in1 * in1;
}
}
);
Assert.assertTrue(loopResult.getIsCompleted());
Assert.assertNotNull(loopResult.getResult());
List output=loopResult.getResult();
Assert.assertEquals(input.size(),output.size());
for (int i=0; i < input.size(); i++) {
Assert.assertEquals(i * i,(int)output.get(i));
}
}
APIUtilityVerifier IterativeVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier input=new LinkedList();
for (int i=0; i < 10; i++) {
input.add(i);
}
final List failForList=Arrays.asList(new Integer[]{2,5,7});
ParallelLoopResult loopResult=Parallel.forLoop(input,new LoopBody(){
@Override public Integer run( Integer in1){
if (failForList.contains(in1)) {
return null;
}
return in1 * in1;
}
}
);
Assert.assertFalse(loopResult.getIsCompleted());
Assert.assertNotNull(loopResult.getResult());
List output=loopResult.getResult();
Assert.assertEquals(input.size(),output.size());
for (int i=0; i < input.size(); i++) {
if (failForList.contains(i)) {
Assert.assertNull(output.get(i));
output.set(i,i * i);
}
else {
Assert.assertEquals(i * i,(int)output.get(i));
}
}
}
Class: org.apache.ambari.server.utils.TestShellCommandUtil APIUtilityVerifier BranchVerifier InternalCallVerifier EqualityVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.view.ClusterImplTest InternalCallVerifier EqualityVerifier properties=new HashMap();
properties.put("foo","bar");
expect(cluster.getDesiredConfigByType("core-site")).andReturn(config).anyTimes();
expect(config.getProperties()).andReturn(properties).anyTimes();
replay(cluster,config);
ClusterImpl clusterImpl=new ClusterImpl(cluster);
Assert.assertEquals("bar",clusterImpl.getConfigurationValue("core-site","foo"));
verify(cluster,config);
}
InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.view.DefaultMaskerTest InternalCallVerifier BooleanVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.view.HttpImpersonatorImplTest InternalCallVerifier EqualityVerifier >)null))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
expect(viewContext.getUsername()).andReturn("joe").anyTimes();
replay(streamProvider,urlConnection,viewContext);
HttpImpersonatorImpl impersonator=new HttpImpersonatorImpl(viewContext,streamProvider);
ImpersonatorSetting setting=new ImpersonatorSettingImpl(viewContext);
Assert.assertEquals(responseBody,impersonator.requestURL("spec","requestMethod",setting));
verify(streamProvider,urlConnection,viewContext);
}
InternalCallVerifier EqualityVerifier >)null))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,urlConnection);
HttpImpersonatorImpl impersonator=new HttpImpersonatorImpl(viewContext,streamProvider);
ImpersonatorSetting setting=new ImpersonatorSettingImpl("hive","impersonate");
Assert.assertEquals(responseBody,impersonator.requestURL("spec","requestMethod",setting));
verify(streamProvider,urlConnection);
}
Class: org.apache.ambari.server.view.ViewAmbariStreamProviderTest InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
headers.put("Cookie","FOO=bar");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
headerMap.put("Cookie",Collections.singletonList("FOO=bar; AMBARISESSIONID=abcdefg"));
expect(sessionManager.getCurrentSessionId()).andReturn("abcdefg");
expect(sessionManager.getSessionCookie()).andReturn("AMBARISESSIONID");
expect(controller.getAmbariServerURI("/spec")).andReturn("http://c6401.ambari.apache.org:8080/spec");
expect(streamProvider.processURL(eq("http://c6401.ambari.apache.org:8080/spec"),eq("requestMethod"),aryEq((byte[])null),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,sessionManager,controller,urlConnection,inputStream);
ViewAmbariStreamProvider viewAmbariStreamProvider=new ViewAmbariStreamProvider(streamProvider,sessionManager,controller);
Assert.assertEquals(inputStream,viewAmbariStreamProvider.readFrom("spec","requestMethod",body,headers,true));
verify(streamProvider,sessionManager,urlConnection,inputStream);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
headers.put("Cookie","FOO=bar");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
headerMap.put("Cookie",Collections.singletonList("FOO=bar; AMBARISESSIONID=abcdefg"));
expect(sessionManager.getCurrentSessionId()).andReturn("abcdefg");
expect(sessionManager.getSessionCookie()).andReturn("AMBARISESSIONID");
expect(controller.getAmbariServerURI("/spec")).andReturn("http://c6401.ambari.apache.org:8080/spec");
expect(streamProvider.processURL(eq("http://c6401.ambari.apache.org:8080/spec"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,sessionManager,controller,urlConnection,inputStream);
ViewAmbariStreamProvider viewAmbariStreamProvider=new ViewAmbariStreamProvider(streamProvider,sessionManager,controller);
Assert.assertEquals(inputStream,viewAmbariStreamProvider.readFrom("spec","requestMethod",body,headers,true));
verify(streamProvider,sessionManager,urlConnection,inputStream);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
headers.put("Cookie","FOO=bar");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
headerMap.put("Cookie",Collections.singletonList("FOO=bar; AMBARISESSIONID=abcdefg"));
expect(sessionManager.getCurrentSessionId()).andReturn("abcdefg");
expect(sessionManager.getSessionCookie()).andReturn("AMBARISESSIONID");
expect(controller.getAmbariServerURI("/spec")).andReturn("http://c6401.ambari.apache.org:8080/spec");
expect(streamProvider.processURL(eq("http://c6401.ambari.apache.org:8080/spec"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,sessionManager,controller,urlConnection,inputStream);
ViewAmbariStreamProvider viewAmbariStreamProvider=new ViewAmbariStreamProvider(streamProvider,sessionManager,controller);
Assert.assertEquals(inputStream,viewAmbariStreamProvider.readFrom("spec","requestMethod","params",headers,true));
verify(streamProvider,sessionManager,urlConnection,inputStream);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
headers.put("Cookie","FOO=bar");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
headerMap.put("Cookie",Collections.singletonList("FOO=bar; AMBARISESSIONID=abcdefg"));
expect(sessionManager.getCurrentSessionId()).andReturn("abcdefg");
expect(sessionManager.getSessionCookie()).andReturn("AMBARISESSIONID");
expect(controller.getAmbariServerURI("/spec")).andReturn("http://c6401.ambari.apache.org:8080/spec");
expect(streamProvider.processURL(eq("http://c6401.ambari.apache.org:8080/spec"),eq("requestMethod"),aryEq((byte[])null),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,sessionManager,controller,urlConnection,inputStream);
ViewAmbariStreamProvider viewAmbariStreamProvider=new ViewAmbariStreamProvider(streamProvider,sessionManager,controller);
Assert.assertEquals(inputStream,viewAmbariStreamProvider.readFrom("spec","requestMethod",body,headers,true));
verify(streamProvider,sessionManager,urlConnection,inputStream);
}
Class: org.apache.ambari.server.view.ViewClassLoaderTest APIUtilityVerifier InternalCallVerifier IdentityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier IdentityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.server.view.ViewContextImplTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier properties=viewContext.getProperties();
Assert.assertEquals(8,properties.size());
Assert.assertEquals("/tmp/some/path/User",properties.get("p1"));
Assert.assertEquals("/tmp/path/View",properties.get("p2"));
Assert.assertEquals("/path/Instance",properties.get("p3"));
Assert.assertEquals("/path/to/${unspecified_parameter}",properties.get("p4"));
Assert.assertEquals("/path/to/${incorrect_parameter",properties.get("p5"));
Assert.assertEquals("/path/to/${username}",properties.get("p6"));
Assert.assertEquals("/path/to/$viewName",properties.get("p7"));
Assert.assertNull(properties.get("p8"));
properties=viewContext.getProperties();
Assert.assertEquals(8,properties.size());
Assert.assertEquals("/tmp/some/path/User2",properties.get("p1"));
Assert.assertEquals("/tmp/path/View",properties.get("p2"));
Assert.assertEquals("/path/Instance",properties.get("p3"));
Assert.assertEquals("/path/to/${unspecified_parameter}",properties.get("p4"));
Assert.assertEquals("/path/to/${incorrect_parameter",properties.get("p5"));
Assert.assertEquals("/path/to/${username}",properties.get("p6"));
Assert.assertEquals("/path/to/$viewName",properties.get("p7"));
Assert.assertNull(properties.get("p8"));
}
InternalCallVerifier EqualityVerifier properties=viewContext.getProperties();
Assert.assertEquals(3,properties.size());
Assert.assertEquals("v1",properties.get("p1"));
Assert.assertEquals("v2",properties.get("p2"));
Assert.assertEquals("v3",properties.get("p3"));
}
Class: org.apache.ambari.server.view.ViewExtractorTest APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier Class: org.apache.ambari.server.view.ViewRegistryTest InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier viewInstanceEntities=ViewInstanceEntityTest.getViewInstanceEntities(viewDefinition);
viewDefinition.setInstances(viewInstanceEntities);
Map viewConfigs=Collections.singletonMap(viewArchive,viewDefinition.getConfiguration());
long resourceId=99L;
for ( ViewInstanceEntity viewInstanceEntity : viewInstanceEntities) {
ResourceEntity resourceEntity=new ResourceEntity();
resourceEntity.setId(resourceId);
resourceEntity.setResourceType(resourceTypeEntity);
viewInstanceEntity.setResource(resourceEntity);
}
Map files=new HashMap();
if (System.getProperty("os.name").contains("Windows")) {
files.put("\\var\\lib\\ambari-server\\resources\\views\\work",extractedArchiveDir);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}",archiveDir);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}\\view.xml",entryFile);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}\\WEB-INF/classes",classesDir);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}\\WEB-INF/lib",libDir);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}\\META-INF",metaInfDir);
}
else {
files.put("/var/lib/ambari-server/resources/views/work",extractedArchiveDir);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}",archiveDir);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/view.xml",entryFile);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/WEB-INF/classes",classesDir);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/WEB-INF/lib",libDir);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/META-INF",metaInfDir);
}
Map outputStreams=new HashMap();
outputStreams.put(entryFile,fos);
Map jarFiles=new HashMap();
jarFiles.put(viewArchive,viewJarFile);
expect(configuration.getViewsDir()).andReturn(viewDir).anyTimes();
if (System.getProperty("os.name").contains("Windows")) {
expect(viewDir.getAbsolutePath()).andReturn("\\var\\lib\\ambari-server\\resources\\views").anyTimes();
}
else {
expect(viewDir.getAbsolutePath()).andReturn("/var/lib/ambari-server/resources/views").anyTimes();
}
expect(configuration.getViewExtractionThreadPoolCoreSize()).andReturn(2).anyTimes();
expect(configuration.getViewExtractionThreadPoolMaxSize()).andReturn(3).anyTimes();
expect(configuration.getViewExtractionThreadPoolTimeout()).andReturn(10000L).anyTimes();
expect(viewDir.listFiles()).andReturn(new File[]{viewArchive}).anyTimes();
expect(viewArchive.isDirectory()).andReturn(false);
if (System.getProperty("os.name").contains("Windows")) {
expect(viewArchive.getAbsolutePath()).andReturn("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}").anyTimes();
}
else {
expect(viewArchive.getAbsolutePath()).andReturn("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}").anyTimes();
}
expect(archiveDir.exists()).andReturn(false);
if (System.getProperty("os.name").contains("Windows")) {
expect(archiveDir.getAbsolutePath()).andReturn("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}").anyTimes();
}
else {
expect(archiveDir.getAbsolutePath()).andReturn("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}").anyTimes();
}
expect(archiveDir.mkdir()).andReturn(true);
expect(archiveDir.toURI()).andReturn(new URI("file:./"));
expect(metaInfDir.mkdir()).andReturn(true);
expect(viewJarFile.getNextJarEntry()).andReturn(jarEntry);
expect(viewJarFile.getNextJarEntry()).andReturn(null);
expect(jarEntry.getName()).andReturn("view.xml");
expect(jarEntry.isDirectory()).andReturn(false);
expect(viewJarFile.read(anyObject(byte[].class))).andReturn(10);
expect(viewJarFile.read(anyObject(byte[].class))).andReturn(-1);
fos.write(anyObject(byte[].class),eq(0),eq(10));
fos.flush();
fos.close();
viewJarFile.closeEntry();
viewJarFile.close();
expect(extractedArchiveDir.exists()).andReturn(false);
expect(extractedArchiveDir.mkdir()).andReturn(true);
expect(classesDir.exists()).andReturn(true);
expect(classesDir.toURI()).andReturn(new URI("file:./"));
expect(libDir.exists()).andReturn(true);
expect(libDir.listFiles()).andReturn(new File[]{fileEntry});
expect(fileEntry.toURI()).andReturn(new URI("file:./"));
expect(viewDAO.findByName("MY_VIEW{1.0.0}")).andThrow(new IllegalArgumentException("Expected exception."));
replay(configuration,viewDir,extractedArchiveDir,viewArchive,archiveDir,entryFile,classesDir,libDir,metaInfDir,fileEntry,viewJarFile,jarEntry,fos,viewDAO);
TestViewArchiveUtility archiveUtility=new TestViewArchiveUtility(viewConfigs,files,outputStreams,jarFiles,false);
ViewRegistry registry=getRegistry(viewDAO,viewInstanceDAO,userDAO,memberDAO,privilegeDAO,resourceDAO,resourceTypeDAO,securityHelper,handlerList,null,archiveUtility,ambariMetaInfo);
registry.readViewArchives();
ViewEntity view=null;
long timeout=System.currentTimeMillis() + 10000L;
while ((view == null || !view.getStatus().equals(ViewDefinition.ViewStatus.ERROR)) && System.currentTimeMillis() < timeout) {
view=registry.getDefinition("MY_VIEW","1.0.0");
}
Assert.assertNotNull(view);
Assert.assertEquals(ViewDefinition.ViewStatus.ERROR,view.getStatus());
verify(configuration,viewDir,extractedArchiveDir,viewArchive,archiveDir,entryFile,classesDir,libDir,metaInfDir,fileEntry,viewJarFile,jarEntry,fos,viewDAO);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier privileges=Arrays.asList(privilege1,privilege2);
PrincipalEntity principalEntity=createNiceMock(PrincipalEntity.class);
expect(privilege1.getPrincipal()).andReturn(principalEntity);
expect(privilege2.getPrincipal()).andReturn(principalEntity);
principalEntity.removePrivilege(privilege1);
principalEntity.removePrivilege(privilege2);
expect(privilegeDAO.findByResourceId(3L)).andReturn(privileges);
privilegeDAO.remove(privilege1);
privilegeDAO.remove(privilege2);
viewInstanceDAO.remove(viewInstanceEntity);
handlerList.removeViewInstance(viewInstanceEntity);
replay(viewInstanceDAO,privilegeDAO,handlerList,privilege1,privilege2,principalEntity);
registry.addDefinition(viewEntity);
registry.addInstanceDefinition(viewEntity,viewInstanceEntity);
registry.uninstallViewInstance(viewInstanceEntity);
Collection viewInstanceDefinitions=registry.getInstanceDefinitions(viewEntity);
Assert.assertEquals(0,viewInstanceDefinitions.size());
verify(viewInstanceDAO,privilegeDAO,handlerList,privilege1,privilege2,principalEntity);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier subResourceDefinitions=registry.getSubResourceDefinitions(viewDefinition.getCommonName(),viewDefinition.getVersion());
Assert.assertEquals(3,subResourceDefinitions.size());
Set names=new HashSet();
for ( SubResourceDefinition definition : subResourceDefinitions) {
names.add(definition.getType().name());
}
Assert.assertTrue(names.contains("MY_VIEW{1.0.0}/resources"));
Assert.assertTrue(names.contains("MY_VIEW{1.0.0}/resource"));
Assert.assertTrue(names.contains("MY_VIEW{1.0.0}/subresource"));
}
InternalCallVerifier EqualityVerifier viewDefinitions=registry.getDefinitions();
Assert.assertEquals(1,viewDefinitions.size());
Assert.assertEquals(viewDefinition,viewDefinitions.iterator().next());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier emptyMap(),VIEW_XML_1);
registry.fireEvent(event);
Assert.assertEquals(event,listener.getLastEvent());
listener.clear();
event=EventImplTest.getEvent("MyEvent",Collections.emptyMap(),VIEW_XML_2);
registry.fireEvent(event);
Assert.assertEquals(event,listener.getLastEvent());
listener.clear();
registry.unregisterListener(listener,"MY_VIEW",null);
event=EventImplTest.getEvent("MyEvent",Collections.emptyMap(),VIEW_XML_1);
registry.fireEvent(event);
Assert.assertNull(listener.getLastEvent());
event=EventImplTest.getEvent("MyEvent",Collections.emptyMap(),VIEW_XML_2);
registry.fireEvent(event);
Assert.assertNull(listener.getLastEvent());
}
InternalCallVerifier BooleanVerifier instances=new ArrayList();
instances.add(instanceEntity);
expect(viewEntity.getInstances()).andReturn(instances);
expect(instanceEntity.getResource()).andReturn(resourceEntity);
expect(resourceEntity.getId()).andReturn(54L).anyTimes();
expect(resourceEntity.getResourceType()).andReturn(resourceTypeEntity).anyTimes();
expect(resourceTypeEntity.getId()).andReturn(ResourceType.VIEW.getId()).anyTimes();
expect(resourceTypeEntity.getName()).andReturn(ResourceType.VIEW.name()).anyTimes();
replay(viewEntity,instanceEntity,resourceEntity,resourceTypeEntity,configuration);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createViewUser(resourceEntity.getId()));
Assert.assertTrue(registry.includeDefinition(viewEntity));
verify(viewEntity,instanceEntity,resourceEntity,resourceTypeEntity,configuration);
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier BooleanVerifier HybridVerifier viewInstanceDefinitions=registry.getInstanceDefinitions(viewEntity);
Assert.assertTrue(viewInstanceDefinitions.isEmpty());
verify(viewDAO,viewInstanceDAO,securityHelper,handlerList,validator,result);
}
APIUtilityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier viewInstanceDefinitions=registry.getInstanceDefinitions(viewEntity);
Assert.assertEquals(1,viewInstanceDefinitions.size());
ViewInstanceEntity instanceEntity=viewInstanceDefinitions.iterator().next();
Assert.assertEquals("v2-1",instanceEntity.getProperty("p2").getValue());
Assert.assertEquals(viewInstanceEntity,viewInstanceDefinitions.iterator().next());
verify(viewDAO,viewInstanceDAO,securityHelper,validator,result);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier viewInstanceDefinitions=registry.getInstanceDefinitions(viewEntity);
Assert.assertEquals(1,viewInstanceDefinitions.size());
ViewInstanceEntity instanceEntity=viewInstanceDefinitions.iterator().next();
Assert.assertEquals("v2-1",instanceEntity.getProperty("p2").getValue());
Assert.assertEquals(viewInstanceEntity,viewInstanceDefinitions.iterator().next());
verify(viewDAO,viewInstanceDAO,securityHelper,validator,result);
}
InternalCallVerifier EqualityVerifier viewInstanceDefinitions=registry.getInstanceDefinitions(viewEntity);
Assert.assertEquals(1,viewInstanceDefinitions.size());
Assert.assertEquals(viewInstanceEntity,viewInstanceDefinitions.iterator().next());
}
InternalCallVerifier BooleanVerifier emptyList()).anyTimes();
replay(viewEntity,configuration);
SecurityContextHolder.getContext().setAuthentication(TestAuthenticationFactory.createViewUser(1L));
Assert.assertFalse(registry.includeDefinition(viewEntity));
verify(viewEntity,configuration);
}
InternalCallVerifier EqualityVerifier viewInstanceDefinitions=registry.getInstanceDefinitions(viewDefinition);
Assert.assertEquals(1,viewInstanceDefinitions.size());
Assert.assertEquals(viewInstanceDefinition,viewInstanceDefinitions.iterator().next());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier emptyMap(),VIEW_XML_1);
registry.fireEvent(event);
Assert.assertEquals(event,listener.getLastEvent());
listener.clear();
event=EventImplTest.getEvent("MyEvent",Collections.emptyMap(),VIEW_XML_2);
registry.fireEvent(event);
Assert.assertNull(listener.getLastEvent());
registry.unregisterListener(listener,"MY_VIEW","1.0.0");
event=EventImplTest.getEvent("MyEvent",Collections.emptyMap(),VIEW_XML_1);
registry.fireEvent(event);
Assert.assertNull(listener.getLastEvent());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier viewInstanceDefinitions=registry.getInstanceDefinitions(viewEntity);
Assert.assertEquals(1,viewInstanceDefinitions.size());
ViewInstanceEntity instanceEntity=viewInstanceDefinitions.iterator().next();
Assert.assertEquals("v2-1",instanceEntity.getProperty("p2").getValue());
Assert.assertEquals("new label",instanceEntity.getLabel());
Assert.assertEquals("new description",instanceEntity.getDescription());
Assert.assertFalse(instanceEntity.isVisible());
Assert.assertEquals(viewInstanceEntity,viewInstanceDefinitions.iterator().next());
verify(viewDAO,viewInstanceDAO,securityHelper);
}
APIUtilityVerifier BranchVerifier InternalCallVerifier BooleanVerifier viewInstanceEntities=ViewInstanceEntityTest.getViewInstanceEntities(viewDefinition);
viewDefinition.setInstances(viewInstanceEntities);
Map viewConfigs=Collections.singletonMap(viewArchive,viewDefinition.getConfiguration());
long resourceId=99L;
for ( ViewInstanceEntity viewInstanceEntity : viewInstanceEntities) {
ResourceEntity resourceEntity=new ResourceEntity();
resourceEntity.setId(resourceId);
resourceEntity.setResourceType(resourceTypeEntity);
viewInstanceEntity.setResource(resourceEntity);
}
Map files=new HashMap();
if (System.getProperty("os.name").contains("Windows")) {
files.put("\\var\\lib\\ambari-server\\resources\\views\\my_view-1.0.0.jar",viewArchive);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work",extractedArchiveDir);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}",archiveDir);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}\\view.xml",entryFile);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}\\WEB-INF\\classes",classesDir);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}\\WEB-INF\\lib",libDir);
files.put("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}\\META-INF",metaInfDir);
}
else {
files.put("/var/lib/ambari-server/resources/views/my_view-1.0.0.jar",viewArchive);
files.put("/var/lib/ambari-server/resources/views/work",extractedArchiveDir);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}",archiveDir);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/view.xml",entryFile);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/WEB-INF/classes",classesDir);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/WEB-INF/lib",libDir);
files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/META-INF",metaInfDir);
}
Map outputStreams=new HashMap();
outputStreams.put(entryFile,fos);
Map jarFiles=new HashMap();
jarFiles.put(viewArchive,viewJarFile);
expect(configuration.getViewsDir()).andReturn(viewDir);
if (System.getProperty("os.name").contains("Windows")) {
expect(viewDir.getAbsolutePath()).andReturn("\\var\\lib\\ambari-server\\resources\\views");
}
else {
expect(viewDir.getAbsolutePath()).andReturn("/var/lib/ambari-server/resources/views");
}
expect(configuration.getViewExtractionThreadPoolCoreSize()).andReturn(2).anyTimes();
expect(configuration.getViewExtractionThreadPoolMaxSize()).andReturn(3).anyTimes();
expect(configuration.getViewExtractionThreadPoolTimeout()).andReturn(10000L).anyTimes();
if (System.getProperty("os.name").contains("Windows")) {
expect(viewArchive.getAbsolutePath()).andReturn("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}").anyTimes();
}
else {
expect(viewArchive.getAbsolutePath()).andReturn("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}").anyTimes();
}
expect(archiveDir.exists()).andReturn(false);
if (System.getProperty("os.name").contains("Windows")) {
expect(archiveDir.getAbsolutePath()).andReturn("\\var\\lib\\ambari-server\\resources\\views\\work\\MY_VIEW{1.0.0}").anyTimes();
}
else {
expect(archiveDir.getAbsolutePath()).andReturn("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}").anyTimes();
}
Capture viewEntityCapture=new Capture();
if (System.getProperty("os.name").contains("Windows")) {
expect(viewExtractor.ensureExtractedArchiveDirectory("\\var\\lib\\ambari-server\\resources\\views\\work")).andReturn(true);
}
else {
expect(viewExtractor.ensureExtractedArchiveDirectory("/var/lib/ambari-server/resources/views/work")).andReturn(true);
}
expect(viewExtractor.extractViewArchive(capture(viewEntityCapture),eq(viewArchive),eq(archiveDir))).andReturn(null);
replay(configuration,viewDir,extractedArchiveDir,viewArchive,archiveDir,entryFile,classesDir,libDir,metaInfDir,fileEntry,viewJarFile,jarEntry,is,fos,viewExtractor,resourceDAO,viewDAO,viewInstanceDAO);
TestViewArchiveUtility archiveUtility=new TestViewArchiveUtility(viewConfigs,files,outputStreams,jarFiles,false);
TestViewModule module=new TestViewModule(viewExtractor,archiveUtility,configuration);
if (System.getProperty("os.name").contains("Windows")) {
Assert.assertTrue(ViewRegistry.extractViewArchive("\\var\\lib\\ambari-server\\resources\\views\\my_view-1.0.0.jar",module,true));
}
else {
Assert.assertTrue(ViewRegistry.extractViewArchive("/var/lib/ambari-server/resources/views/my_view-1.0.0.jar",module,true));
}
verify(configuration,viewDir,extractedArchiveDir,viewArchive,archiveDir,entryFile,classesDir,libDir,metaInfDir,fileEntry,viewJarFile,jarEntry,is,fos,viewExtractor,resourceDAO,viewDAO,viewInstanceDAO);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier viewInstanceDefinitions=registry.getInstanceDefinitions(viewEntity);
Assert.assertEquals(1,viewInstanceDefinitions.size());
ViewInstanceEntity instanceEntity=viewInstanceDefinitions.iterator().next();
Assert.assertEquals("v2-1",instanceEntity.getProperty("p2").getValue());
Assert.assertEquals(viewInstanceEntity,viewInstanceDefinitions.iterator().next());
verify(viewDAO,viewInstanceDAO,securityHelper,handlerList,validator,result);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier instanceProperties=new HashMap();
instanceProperties.put("p1","newV1");
instanceProperties.put("p2","newV2");
registry.setViewInstanceProperties(viewInstanceEntity,instanceProperties,viewEntity.getConfiguration(),viewEntity.getClassLoader());
Assert.assertEquals("newV1",viewInstanceEntity.getProperty("p1").getValue());
Assert.assertEquals("bmV3VjI=",viewInstanceEntity.getProperty("p2").getValue());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier viewInstanceDefinitions=registry.getInstanceDefinitions(viewEntity);
Assert.assertEquals(1,viewInstanceDefinitions.size());
ViewInstanceEntity instanceEntity=viewInstanceDefinitions.iterator().next();
Assert.assertEquals("v2-1",instanceEntity.getProperty("p2").getValue());
Assert.assertEquals(viewInstanceEntity,viewInstanceDefinitions.iterator().next());
Assert.assertEquals("MY_VIEW{1.0.0}",viewInstanceEntity.getResource().getResourceType().getName());
verify(viewDAO,viewInstanceDAO,resourceTypeDAO,securityHelper,handlerList);
}
InternalCallVerifier NullVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier providerMap=registry.getResourceProviders();
Assert.assertEquals(3,providerMap.size());
Assert.assertTrue(providerMap.containsKey(Resource.Type.valueOf("MY_VIEW{1.0.0}/resource")));
Assert.assertTrue(providerMap.containsKey(Resource.Type.valueOf("MY_VIEW{1.0.0}/subresource")));
Assert.assertTrue(providerMap.containsKey(Resource.Type.valueOf("MY_VIEW{1.0.0}/resources")));
}
Class: org.apache.ambari.server.view.ViewSubResourceDefinitionTest InternalCallVerifier EqualityVerifier subResourceDefinitions=viewSubResourceDefinition.getSubResourceDefinitions();
Assert.assertEquals(1,subResourceDefinitions.size());
Assert.assertEquals("MY_VIEW{1.0.0}/subresource",subResourceDefinitions.iterator().next().getType().name());
}
Class: org.apache.ambari.server.view.ViewSubResourceProviderTest APIUtilityVerifier InternalCallVerifier EqualityVerifier resourceDefinitions=viewEntity.getResourceDefinitions();
Assert.assertEquals(1,resourceDefinitions.size());
Resource.Type type=resourceDefinitions.keySet().iterator().next();
ViewSubResourceProvider viewSubResourceProvider=new ViewSubResourceProvider(type,MyResource.class,"id",viewEntity);
Set requestProperties=new HashSet();
requestProperties.add("metrics/myMetric");
Map temporalInfoMap=new HashMap();
TemporalInfo temporalInfo=new TemporalInfoImpl(1000L,1100L,10L);
temporalInfoMap.put("metrics/myMetric",temporalInfo);
Request request=PropertyHelper.getReadRequest(requestProperties,temporalInfoMap);
Predicate predicate=new AlwaysPredicate();
Set resources=viewSubResourceProvider.getResources(request,predicate);
Assert.assertEquals(2,resources.size());
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier resourceDefinitions=viewEntity.getResourceDefinitions();
Assert.assertEquals(1,resourceDefinitions.size());
Resource.Type type=resourceDefinitions.keySet().iterator().next();
ViewSubResourceProvider viewSubResourceProvider=new ViewSubResourceProvider(type,MyResource.class,"id",viewEntity);
Request request=PropertyHelper.getReadRequest("id","properties","metrics/myMetric");
Predicate predicate=new AlwaysPredicate();
Set resources=viewSubResourceProvider.getResources(request,predicate);
Assert.assertEquals(2,resources.size());
predicate=new PredicateBuilder().property("metrics/myMetric").greaterThan(1).toPredicate();
resources=viewSubResourceProvider.getResources(request,predicate);
Assert.assertEquals(1,resources.size());
Assert.assertTrue(((Integer)resources.iterator().next().getPropertyValue("metrics/myMetric")) > 1);
}
Class: org.apache.ambari.server.view.ViewURLStreamProviderTest InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec"),eq("requestMethod"),aryEq((byte[])null),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,urlConnection,inputStream);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(inputStream,viewURLStreamProvider.readFrom("spec","requestMethod",(String)null,headers));
verify(streamProvider,urlConnection,inputStream);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
replay(streamProvider,urlConnection);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(urlConnection,viewURLStreamProvider.getConnection("spec","requestMethod","params",headers));
verify(streamProvider,urlConnection);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec?doAs=joe"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
replay(streamProvider,urlConnection);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(urlConnection,viewURLStreamProvider.getConnectionAs("spec","requestMethod","params",headers,"joe"));
verify(streamProvider,urlConnection);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec"),eq("requestMethod"),aryEq((byte[])null),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,urlConnection,inputStream);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(inputStream,viewURLStreamProvider.readFrom("spec","requestMethod",(InputStream)null,headers));
verify(streamProvider,urlConnection,inputStream);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec?doAs=joe"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
expect(viewContext.getUsername()).andReturn("joe").anyTimes();
replay(streamProvider,urlConnection,viewContext);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(urlConnection,viewURLStreamProvider.getConnectionAsCurrent("spec","requestMethod","params",headers));
verify(streamProvider,urlConnection,viewContext);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec?doAs=joe"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,urlConnection,inputStream);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(inputStream,viewURLStreamProvider.readAs("spec","requestMethod","params",headers,"joe"));
verify(streamProvider,urlConnection,inputStream);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec?doAs=joe"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
expect(viewContext.getUsername()).andReturn("joe").anyTimes();
replay(streamProvider,urlConnection,inputStream,viewContext);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(inputStream,viewURLStreamProvider.readAsCurrent("spec","requestMethod",body,headers));
verify(streamProvider,urlConnection,inputStream,viewContext);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec?doAs=joe"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,urlConnection,inputStream);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(inputStream,viewURLStreamProvider.readAs("spec","requestMethod",body,headers,"joe"));
verify(streamProvider,urlConnection,inputStream);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,urlConnection,inputStream);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(inputStream,viewURLStreamProvider.readFrom("spec","requestMethod",body,headers));
verify(streamProvider,urlConnection,inputStream);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec?doAs=joe"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
expect(viewContext.getUsername()).andReturn("joe").anyTimes();
replay(streamProvider,urlConnection,inputStream,viewContext);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(inputStream,viewURLStreamProvider.readAsCurrent("spec","requestMethod","params",headers));
verify(streamProvider,urlConnection,inputStream,viewContext);
}
InternalCallVerifier EqualityVerifier headers=new HashMap();
headers.put("header","headerValue");
Map> headerMap=new HashMap>();
headerMap.put("header",Collections.singletonList("headerValue"));
expect(streamProvider.processURL(eq("spec"),eq("requestMethod"),aryEq("params".getBytes()),eq(headerMap))).andReturn(urlConnection);
expect(urlConnection.getInputStream()).andReturn(inputStream);
replay(streamProvider,urlConnection,inputStream);
ViewURLStreamProvider viewURLStreamProvider=new ViewURLStreamProvider(viewContext,streamProvider);
Assert.assertEquals(inputStream,viewURLStreamProvider.readFrom("spec","requestMethod","params",headers));
verify(streamProvider,urlConnection,inputStream);
}
Class: org.apache.ambari.server.view.configuration.AutoInstanceConfigTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier serviceNames=config.getServices();
assertEquals(2,serviceNames.size());
assertTrue(serviceNames.contains("HIVE"));
assertTrue(serviceNames.contains("HDFS"));
}
Class: org.apache.ambari.server.view.configuration.PersistenceConfigTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.server.view.configuration.PropertyConfigTest BranchVerifier InternalCallVerifier BooleanVerifier instanceConfigs=InstanceConfigTest.getInstanceConfigs();
for ( InstanceConfig instanceConfig : instanceConfigs) {
List propertyConfigs=instanceConfig.getProperties();
Assert.assertTrue(propertyConfigs.size() <= 2);
Assert.assertTrue(propertyConfigs.get(0).getValue().startsWith("v1-"));
if (propertyConfigs.size() == 2) {
Assert.assertTrue(propertyConfigs.get(1).getValue().startsWith("v2-"));
}
}
}
BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier instanceConfigs=InstanceConfigTest.getInstanceConfigs();
for ( InstanceConfig instanceConfig : instanceConfigs) {
List propertyConfigs=instanceConfig.getProperties();
Assert.assertTrue(propertyConfigs.size() <= 2);
Assert.assertEquals("p1",propertyConfigs.get(0).getKey());
if (propertyConfigs.size() == 2) {
Assert.assertEquals("p2",propertyConfigs.get(1).getKey());
}
}
}
Class: org.apache.ambari.server.view.configuration.ViewConfigTest APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier resources=config.getResources();
Assert.assertEquals(2,resources.size());
Assert.assertEquals("resource",resources.get(0).getName());
Assert.assertEquals("subresource",resources.get(1).getName());
config=getConfig(minimal_xml);
resources=config.getResources();
Assert.assertNotNull(resources);
Assert.assertEquals(0,resources.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier instances=config.getInstances();
Assert.assertEquals(2,instances.size());
Assert.assertEquals("INSTANCE1",instances.get(0).getName());
Assert.assertEquals("INSTANCE2",instances.get(1).getName());
config=getConfig(minimal_xml);
instances=config.getInstances();
Assert.assertNotNull(instances);
Assert.assertEquals(0,instances.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier parameters=config.getParameters();
Assert.assertEquals(2,parameters.size());
Assert.assertEquals("p1",parameters.get(0).getName());
Assert.assertEquals("p2",parameters.get(1).getName());
config=getConfig(minimal_xml);
parameters=config.getParameters();
Assert.assertNotNull(parameters);
Assert.assertEquals(0,parameters.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.server.view.events.EventImplTest APIUtilityVerifier InternalCallVerifier EqualityVerifier emptyMap(),view_xml);
Assert.assertEquals("MY_VIEW",event.getViewSubject().getViewName());
Assert.assertEquals("My View!",event.getViewSubject().getLabel());
Assert.assertEquals("1.0.0",event.getViewSubject().getVersion());
}
Class: org.apache.ambari.server.view.persistence.DataStoreImplTest APIUtilityVerifier InternalCallVerifier EqualityVerifier typeCapture=new Capture();
Capture typeCapture2=new Capture();
jpaDynamicHelper.addTypes(eq(true),eq(true),capture(typeCapture),capture(typeCapture2));
expect(entityManagerFactory.createEntityManager()).andReturn(entityManager);
expect(entityManager.createQuery("SELECT e FROM DS_DataStoreImplTest$TestEntity_1 e WHERE e.DS_name='foo'")).andReturn(query);
entityManager.close();
List entityList=new LinkedList();
entityList.add(dynamicEntity1);
entityList.add(dynamicEntity2);
entityList.add(dynamicEntity3);
expect(query.getResultList()).andReturn(entityList);
expect(dynamicEntity1.get("DS_id")).andReturn(99);
expect(dynamicEntity1.get("DS_name")).andReturn("foo");
TestSubEntity subEntity1=new TestSubEntity("bar");
expect(dynamicEntity1.get("DS_subEntity")).andReturn(subEntity1);
expect(dynamicEntity2.get("DS_id")).andReturn(100);
expect(dynamicEntity2.get("DS_name")).andReturn("foo");
TestSubEntity subEntity2=new TestSubEntity("bar");
expect(dynamicEntity2.get("DS_subEntity")).andReturn(subEntity2);
expect(dynamicEntity3.get("DS_id")).andReturn(101);
expect(dynamicEntity3.get("DS_name")).andReturn("foo");
TestSubEntity subEntity3=new TestSubEntity("bar");
expect(dynamicEntity3.get("DS_subEntity")).andReturn(subEntity3);
replay(entityManagerFactory,entityManager,jpaDynamicHelper,dynamicEntity1,dynamicEntity2,dynamicEntity3,query,schemaManager);
DataStoreImpl dataStore=getDataStore(entityManagerFactory,jpaDynamicHelper,classLoader,schemaManager);
Collection entities=dataStore.findAll(TestEntity.class,"name='foo'");
Assert.assertEquals(3,entities.size());
for ( TestEntity entity : entities) {
Assert.assertEquals("foo",entity.getName());
}
verify(entityManagerFactory,entityManager,jpaDynamicHelper,dynamicEntity1,dynamicEntity2,dynamicEntity3,query,schemaManager);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier typeCapture=new Capture();
Capture typeCapture2=new Capture();
jpaDynamicHelper.addTypes(eq(true),eq(true),capture(typeCapture),capture(typeCapture2));
expect(entityManagerFactory.createEntityManager()).andReturn(entityManager);
Capture entityClassCapture=new Capture();
expect(entityManager.find(capture(entityClassCapture),eq(99))).andReturn(dynamicEntity);
entityManager.close();
expect(dynamicEntity.get("DS_id")).andReturn(99);
expect(dynamicEntity.get("DS_name")).andReturn("foo");
TestSubEntity subEntity=new TestSubEntity("bar");
expect(dynamicEntity.get("DS_subEntity")).andReturn(subEntity);
replay(entityManagerFactory,entityManager,jpaDynamicHelper,dynamicEntity,schemaManager);
DataStoreImpl dataStore=getDataStore(entityManagerFactory,jpaDynamicHelper,classLoader,schemaManager);
TestEntity entity=dataStore.find(TestEntity.class,99);
Assert.assertEquals(entityClassCapture.getValue(),typeCapture2.getValue().getJavaClass());
Assert.assertEquals(99,entity.getId());
Assert.assertEquals("foo",entity.getName());
verify(entityManagerFactory,entityManager,jpaDynamicHelper,dynamicEntity,schemaManager);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier typeCapture=new Capture();
Capture typeCapture2=new Capture();
jpaDynamicHelper.addTypes(eq(true),eq(true),capture(typeCapture),capture(typeCapture2));
expect(entityManagerFactory.createEntityManager()).andReturn(entityManager);
expect(entityManager.createQuery("SELECT e FROM DS_DataStoreImplTest$TestEntity_1 e WHERE e.DS_id=99")).andReturn(query);
entityManager.close();
expect(query.getResultList()).andReturn(Collections.singletonList(dynamicEntity));
expect(dynamicEntity.get("DS_id")).andReturn(99);
expect(dynamicEntity.get("DS_name")).andReturn("foo");
TestSubEntity subEntity=new TestSubEntity("bar");
expect(dynamicEntity.get("DS_subEntity")).andReturn(subEntity);
replay(entityManagerFactory,entityManager,jpaDynamicHelper,dynamicEntity,query,schemaManager);
DataStoreImpl dataStore=getDataStore(entityManagerFactory,jpaDynamicHelper,classLoader,schemaManager);
Collection entities=dataStore.findAll(TestEntity.class,"id=99");
Assert.assertEquals(1,entities.size());
TestEntity entity=entities.iterator().next();
Assert.assertEquals(99,entity.getId());
Assert.assertEquals("foo",entity.getName());
verify(entityManagerFactory,entityManager,jpaDynamicHelper,dynamicEntity,query,schemaManager);
}
InternalCallVerifier EqualityVerifier typeCapture=new Capture();
Capture typeCapture2=new Capture();
jpaDynamicHelper.addTypes(eq(true),eq(true),capture(typeCapture),capture(typeCapture2));
expect(entityManagerFactory.createEntityManager()).andReturn(entityManager);
expect(entityManager.getTransaction()).andReturn(transaction).anyTimes();
Capture entityClassCapture=new Capture();
expect(entityManager.find(capture(entityClassCapture),eq("bar"))).andReturn(null);
Capture entityClassCapture2=new Capture();
expect(entityManager.find(capture(entityClassCapture2),eq(99))).andReturn(null);
Capture entityCapture=new Capture();
entityManager.persist(capture(entityCapture));
Capture entityCapture2=new Capture();
entityManager.persist(capture(entityCapture2));
entityManager.close();
transaction.begin();
transaction.commit();
replay(entityManagerFactory,entityManager,jpaDynamicHelper,transaction,schemaManager);
DataStoreImpl dataStore=getDataStore(entityManagerFactory,jpaDynamicHelper,classLoader,schemaManager);
dataStore.store(new TestEntity(99,"foo",new TestSubEntity("bar")));
Assert.assertEquals(entityClassCapture.getValue(),typeCapture.getValue().getJavaClass());
Assert.assertEquals(entityClassCapture2.getValue(),typeCapture2.getValue().getJavaClass());
Assert.assertEquals("bar",entityCapture.getValue().get("DS_name"));
Assert.assertEquals(99,entityCapture2.getValue().get("DS_id"));
Assert.assertEquals("foo",entityCapture2.getValue().get("DS_name"));
verify(entityManagerFactory,entityManager,jpaDynamicHelper,transaction,schemaManager);
}
Class: org.apache.ambari.server.view.validation.InstanceValidationResultImplTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier propertyResults=new HashMap();
propertyResults.put("foo",new ValidationResultImpl(true,"foo detail"));
propertyResults.put("bar",new ValidationResultImpl(false,"bar detail"));
InstanceValidationResultImpl instanceValidationResult=new InstanceValidationResultImpl(result,propertyResults);
propertyResults=instanceValidationResult.getPropertyResults();
Assert.assertEquals(2,propertyResults.size());
Assert.assertTrue(propertyResults.containsKey("foo"));
Assert.assertTrue(propertyResults.containsKey("bar"));
Assert.assertTrue(propertyResults.get("foo").isValid());
Assert.assertFalse(propertyResults.get("bar").isValid());
}
Class: org.apache.ambari.server.view.validation.ValidationResultImplTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.shell.commands.BlueprintCommandsTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.shell.commands.ClusterCommandsTest InternalCallVerifier EqualityVerifier > map=singletonMap("group1",asList("host","host2"));
ReflectionTestUtils.setField(clusterCommands,"hostGroups",map);
when(client.getHostNames()).thenReturn(singletonMap("host3","HEALTHY"));
String result=clusterCommands.assign(new Host("host3"),"group0");
assertEquals("group0 is not a valid host group",result);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier > map=singletonMap("group1",asList("host","host2"));
ReflectionTestUtils.setField(clusterCommands,"hostGroups",map);
when(context.getFocusValue()).thenReturn(blueprint);
when(client.getClusterName()).thenReturn("cluster");
String result=clusterCommands.createCluster(false);
verify(client).createCluster(blueprint,blueprint,map);
verify(context).resetFocus();
assertFalse(result.contains("Failed"));
assertTrue(result.contains("Successfully"));
}
InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier > hostGroups=singletonMap("group1",asList("host1"));
ReflectionTestUtils.setField(clusterCommands,"hostGroups",hostGroups);
when(context.getFocusValue()).thenReturn("blueprint");
when(client.recommendAssignments("blueprint")).thenReturn(new HashMap>());
clusterCommands.autoAssign();
Map> result=(Map>)ReflectionTestUtils.getField(clusterCommands,"hostGroups");
assertEquals(hostGroups,result);
}
InternalCallVerifier EqualityVerifier > map=new HashMap>();
map.put("group1",new ArrayList());
ReflectionTestUtils.setField(clusterCommands,"hostGroups",map);
when(client.getHostNames()).thenReturn(singletonMap("host3","HEALTHY"));
String result=clusterCommands.assign(new Host("host3"),"group1");
assertEquals("host3 has been added to group1",result);
}
InternalCallVerifier BooleanVerifier > map=singletonMap("group1",asList("host","host2"));
ReflectionTestUtils.setField(clusterCommands,"hostGroups",map);
when(context.getFocusValue()).thenReturn(blueprint);
doThrow(responseException).when(client).createCluster(blueprint,blueprint,map);
doThrow(responseException).when(client).deleteCluster(blueprint);
String result=clusterCommands.createCluster(false);
verify(client).createCluster(blueprint,blueprint,map);
verify(client).getHostGroups(blueprint);
verify(client).deleteCluster(blueprint);
assertTrue(result.contains("Failed"));
}
InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier > hostGroups=singletonMap("group1",asList("host1"));
Map> newAssignments=singletonMap("group1",asList("host1"));
ReflectionTestUtils.setField(clusterCommands,"hostGroups",hostGroups);
when(context.getFocusValue()).thenReturn("blueprint");
when(client.recommendAssignments("blueprint")).thenReturn(newAssignments);
clusterCommands.autoAssign();
Map> result=(Map>)ReflectionTestUtils.getField(clusterCommands,"hostGroups");
assertEquals(newAssignments,result);
verify(context).setHint(Hints.CREATE_CLUSTER);
}
InternalCallVerifier EqualityVerifier hostNames=singletonMap("host1","HEALTHY");
Map> map=singletonMap("group1",asList("comp1","comp2"));
when(client.doesBlueprintExist("id")).thenReturn(true);
when(client.getBlueprintMap("id")).thenReturn(map);
when(context.getFocusValue()).thenReturn("id");
when(client.getHostNames()).thenReturn(hostNames);
String result=clusterCommands.buildCluster(new Blueprint("id"));
verify(client).doesBlueprintExist("id");
verify(client).getBlueprintMap("id");
verify(client).getHostGroups("id");
assertEquals(String.format("%s\n%s",renderSingleMap(hostNames,"HOSTNAME","STATE"),renderMultiValueMap(map,"HOSTGROUP","COMPONENT")),result);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier EqualityVerifier > map=new HashMap>();
map.put("group1",new ArrayList());
ReflectionTestUtils.setField(clusterCommands,"hostGroups",map);
when(client.getHostNames()).thenReturn(singletonMap("host2","HEALTHY"));
String result=clusterCommands.assign(new Host("host3"),"group1");
assertEquals("host3 is not a valid hostname",result);
}
InternalCallVerifier BooleanVerifier Class: org.apache.ambari.shell.commands.HostCommandsTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.shell.customization.AmbariPromptTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.shell.model.AmbariContextTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.view.capacityscheduler.ConfigurationServiceTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.view.filebrowser.FilebrowserTest APIUtilityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.view.filebrowser.PropertyValidatorTest APIUtilityVerifier InternalCallVerifier EqualityVerifier propertyMap=new HashMap();
propertyMap.put(PropertyValidator.WEBHDFS_URL,"hdfs://host:1234/");
ViewInstanceDefinition instanceDefinition=getInstanceDef(propertyMap);
ValidationResult result=new PropertyValidator().validateProperty(PropertyValidator.WEBHDFS_URL,instanceDefinition,null);
assertEquals(result,ValidationResult.SUCCESS);
assertEquals(result.isValid(),true);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier propertyMap=new HashMap();
propertyMap.put(PropertyValidator.WEBHDFS_URL,"webhdfs://host:1234/");
ViewInstanceDefinition instanceDefinition=getInstanceDef(propertyMap);
ValidationResult result=new PropertyValidator().validateProperty(PropertyValidator.WEBHDFS_URL,instanceDefinition,null);
assertEquals(result,ValidationResult.SUCCESS);
assertEquals(result.isValid(),true);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier propertyMap=new HashMap();
propertyMap.put(PropertyValidator.WEBHDFS_URL,"file:///");
ViewInstanceDefinition instanceDefinition=getInstanceDef(propertyMap);
ValidationResult result=new PropertyValidator().validateProperty(PropertyValidator.WEBHDFS_URL,instanceDefinition,null);
assertEquals(result.getClass(),PropertyValidator.InvalidPropertyValidationResult.class);
assertEquals(result.isValid(),false);
assertEquals(result.getDetail(),"Must be valid URL");
}
Class: org.apache.ambari.view.hive.PropertyValidatorTest InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier InternalCallVerifier BooleanVerifier Class: org.apache.ambari.view.hive.resources.files.FileServiceTest APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier >anyObject())).andReturn(inputStream);
fileService=getService(FileService.class,handler,context);
replay(context,urlStreamProvider);
Response response=fileService.getFilePage(filepath,0l);
ServiceTestUtils.assertHTTPResponseOK(response);
JSONObject obj=((JSONObject)response.getEntity());
assertFileJsonResponseSanity(obj);
FileResource fileResource=(FileResource)obj.get("file");
Assert.assertEquals("Query Content",fileResource.getFileContent());
Assert.assertEquals(0,fileResource.getPage());
Assert.assertFalse(fileResource.isHasNext());
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.view.hive.resources.jobs.ATSParserTest InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier jobs=jobLoader.getHiveQueryIdsList("hive");
Assert.assertEquals(1,jobs.size());
HiveQueryId job=jobs.get(0);
Assert.assertEquals("hive_20150209144848_c3a5a07b-c3b6-4f57-a6d5-3dadecdd6fd0",job.entity);
Assert.assertEquals(1423493324L,job.starttime);
Assert.assertEquals("hive",job.user);
Assert.assertEquals(1423493342L - 1423493324L,job.duration);
Assert.assertEquals("select count(*) from z",job.query);
Assert.assertEquals(1,job.dagNames.size());
Assert.assertEquals("hive_20150209144848_c3a5a07b-c3b6-4f57-a6d5-3dadecdd6fd0:4",job.dagNames.get(0));
Assert.assertEquals(2,job.stages.size());
Assert.assertTrue(HiveQueryId.ATS_15_RESPONSE_VERSION > job.version);
jobLoader=new ATSParser(new ATSV15RequestsDelegateStub());
List jobsv2=jobLoader.getHiveQueryIdsList("hive");
Assert.assertEquals(1,jobsv2.size());
HiveQueryId jobv2=jobsv2.get(0);
Assert.assertTrue(HiveQueryId.ATS_15_RESPONSE_VERSION <= jobv2.version);
}
InternalCallVerifier EqualityVerifier Class: org.apache.ambari.view.hive.resources.jobs.AggregatorTest InternalCallVerifier EqualityVerifier aggregated=aggregator.readAll("luke");
Assert.assertEquals(0,aggregated.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier aggregated=aggregator.readAll("luke");
Assert.assertEquals(1,aggregated.size());
Job job=aggregated.get(0);
Assert.assertEquals("ENTITY-NAME",job.getId());
Assert.assertEquals(SOME_QUERY,job.getTitle());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier aggregated=aggregator.readAll("luke");
Assert.assertEquals(1,aggregated.size());
Job job=aggregated.get(0);
Assert.assertEquals("1",job.getId());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier aggregated=aggregator.readAll("luke");
Assert.assertEquals(1,aggregated.size());
Job job=aggregated.get(0);
Assert.assertEquals("1",job.getId());
Assert.assertEquals("app_test_1",job.getApplicationId());
Assert.assertEquals("ENTITY-NAME",job.getDagId());
Assert.assertEquals("SUCCEEDED",job.getStatus());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier aggregated=aggregator.readAll("luke");
Assert.assertEquals(1,aggregated.size());
Job job=aggregated.get(0);
Assert.assertEquals("ENTITY-NAME",job.getId());
Assert.assertEquals(SOME_QUERY,job.getTitle());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier aggregated=aggregator.readAll("luke");
Assert.assertEquals(3,aggregated.size());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier aggregated=aggregator.readAll("luke");
Assert.assertEquals(1,aggregated.size());
Job job=aggregated.get(0);
Assert.assertEquals("1",job.getId());
}
Class: org.apache.ambari.view.hive.resources.jobs.JobServiceTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.view.hive.resources.jobs.LogParserTest APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier \n"+ "INFO : In order to limit the maximum number of reducers:\n"+ "INFO : set hive.exec.reducers.max=\n"+ "INFO : In order to set a constant number of reducers:\n"+ "INFO : set mapreduce.job.reduces=\n"+ "WARN : Hadoop command-line option parsing not performed. Implement the Tool interface and execute your application with ToolRunner to remedy this.\n"+ "INFO : number of splits:1\n"+ "INFO : Submitting tokens for job: job_1421248330903_0003\n"+ "INFO : The url to track the job: http://dataworker.hortonworks.com:8088/proxy/application_1421248330903_0003/\n"+ "INFO : Starting Job = job_1421248330903_0003, Tracking URL = http://dataworker.hortonworks.com:8088/proxy/application_1421248330903_0003/\n"+ "INFO : Kill Command = /usr/hdp/current/hadoop-client/bin/hadoop job -kill job_1421248330903_0003\n"+ "INFO : Hadoop job information for Stage-1: number of mappers: 1; number of reducers: 1\n"+ "INFO : 2015-01-21 15:03:55,979 Stage-1 map = 0%, reduce = 0%\n"+ "INFO : 2015-01-21 15:04:07,503 Stage-1 map = 100%, reduce = 0%, Cumulative CPU 0.79 sec\n"+ "INFO : 2015-01-21 15:04:17,384 Stage-1 map = 100%, reduce = 100%, Cumulative CPU 1.86 sec\n"+ "INFO : MapReduce Total cumulative CPU time: 1 seconds 860 msec\n"+ "INFO : Ended Job = job_1421248330903_0003";
LogParser p=LogParser.parseLog(log);
Assert.assertEquals(1,p.getAppsList().size());
Assert.assertEquals("application_1421248330903_0003",(((LogParser.AppId)(p.getAppsList().toArray())[0]).getIdentifier()));
}
Class: org.apache.ambari.view.hive.resources.resources.FileResourceServiceTest APIUtilityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.view.hive.resources.savedQueries.SavedQueryServiceTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier items=(List)obj.get("savedQueries");
boolean containsTitle=false;
for ( SavedQuery item : items) containsTitle=containsTitle || item.getTitle().compareTo("Title 1") == 0;
Assert.assertTrue(containsTitle);
containsTitle=false;
for ( SavedQuery item : items) containsTitle=containsTitle || item.getTitle().compareTo("Title 2") == 0;
Assert.assertTrue(containsTitle);
}
InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.view.hive.resources.udfs.UDFServiceTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.ambari.view.hive.resources.upload.DataParserTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.view.pig.test.FileTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.view.pig.test.HelpTest InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier Class: org.apache.ambari.view.pig.test.IntegrationalTest APIUtilityVerifier InternalCallVerifier IdentityVerifier APIUtilityVerifier InternalCallVerifier IdentityVerifier Class: org.apache.ambari.view.pig.test.JobTest APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier ();
info.status.put("runState",(double)JobResourceManager.RUN_STATE_RUNNING);
info.percentComplete="30% complete";
expect(api.checkJob(eq("job_id_#"))).andReturn(info);
replay(api);
response=jobService.getJob(job.getId());
Assert.assertEquals(200,response.getStatus());
job=((PigJob)((JSONObject)response.getEntity()).get("job"));
Assert.assertEquals(PigJob.PIG_JOB_STATE_RUNNING,job.getStatus());
Assert.assertTrue(job.isInProgress());
Assert.assertEquals(30,(Object)job.getPercentComplete());
reset(api);
info=api.new JobInfo();
info.status=new HashMap();
info.status.put("runState",(double)JobResourceManager.RUN_STATE_SUCCEEDED);
expect(api.checkJob(eq("job_id_#"))).andReturn(info);
replay(api);
response=jobService.getJob(job.getId());
Assert.assertEquals(200,response.getStatus());
job=((PigJob)((JSONObject)response.getEntity()).get("job"));
Assert.assertEquals(PigJob.PIG_JOB_STATE_COMPLETED,job.getStatus());
Assert.assertFalse(job.isInProgress());
Assert.assertNull(job.getPercentComplete());
reset(api);
info=api.new JobInfo();
info.status=new HashMap();
info.status.put("runState",(double)JobResourceManager.RUN_STATE_PREP);
expect(api.checkJob(eq("job_id_#"))).andReturn(info);
replay(api);
response=jobService.getJob(job.getId());
Assert.assertEquals(200,response.getStatus());
job=((PigJob)((JSONObject)response.getEntity()).get("job"));
Assert.assertEquals(PigJob.PIG_JOB_STATE_RUNNING,job.getStatus());
reset(api);
info=api.new JobInfo();
info.status=new HashMap();
info.status.put("runState",(double)JobResourceManager.RUN_STATE_FAILED);
expect(api.checkJob(eq("job_id_#"))).andReturn(info);
replay(api);
response=jobService.getJob(job.getId());
Assert.assertEquals(200,response.getStatus());
job=((PigJob)((JSONObject)response.getEntity()).get("job"));
Assert.assertEquals(PigJob.PIG_JOB_STATE_FAILED,job.getStatus());
Assert.assertFalse(job.isInProgress());
reset(api);
info=api.new JobInfo();
info.status=new HashMap();
info.status.put("runState",(double)JobResourceManager.RUN_STATE_KILLED);
expect(api.checkJob(eq("job_id_#"))).andReturn(info);
replay(api);
response=jobService.getJob(job.getId());
Assert.assertEquals(200,response.getStatus());
job=((PigJob)((JSONObject)response.getEntity()).get("job"));
Assert.assertEquals(PigJob.PIG_JOB_STATE_KILLED,job.getStatus());
Assert.assertFalse(job.isInProgress());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.view.pig.test.ScriptTest InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier scripts=(List)obj.get("scripts");
boolean containsTitle=false;
for ( PigScript script : scripts) containsTitle=containsTitle || script.getTitle().compareTo("Title 1") == 0;
Assert.assertTrue(containsTitle);
containsTitle=false;
for ( PigScript script : scripts) containsTitle=containsTitle || script.getTitle().compareTo("Title 2") == 0;
Assert.assertTrue(containsTitle);
}
InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.view.pig.test.ScriptTestHDFSUnmanaged InternalCallVerifier BooleanVerifier properties=new HashMap();
baseDir=new File(DATA_DIRECTORY).getAbsoluteFile();
pigStorageFile=new File("./target/BasePigTest/storage.dat").getAbsoluteFile();
properties.put("dataworker.storagePath",pigStorageFile.toString());
properties.put("scripts.dir","/tmp/.pigscripts");
properties.put("webhdfs.url",hdfsURI);
expect(context.getProperties()).andReturn(properties).anyTimes();
expect(context.getUsername()).andReturn("ambari-qa").anyTimes();
replay(handler,context);
scriptService=getService(ScriptService.class,handler,context);
Response createdScript=doCreateScript("Test",null);
String createdScriptPath=((PigScript)((JSONObject)createdScript.getEntity()).get("script")).getPigScript();
Assert.assertTrue(createdScriptPath.startsWith("/tmp/.pigscripts/"));
properties.put("dataworker.username","luke");
Response createdScript2=doCreateScript("Test",null);
String createdScriptPath2=((PigScript)((JSONObject)createdScript2.getEntity()).get("script")).getPigScript();
Assert.assertTrue(createdScriptPath2.startsWith("/tmp/.pigscripts/"));
}
Class: org.apache.ambari.view.pig.test.UDFTest InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.ambari.view.slider.rest.client.SliderAppMasterClientTest InternalCallVerifier EqualityVerifier > matchers=m1.getMatchers();
Assert.assertEquals(matchers.size(),1);
Assert.assertEquals(matchers.get(0).size(),1);
Assert.assertEquals(matchers.get(0).get(0),"c");
m1=new Metric("a_b.c.d",true,false);
Assert.assertEquals(m1.getJmxBeanKeyName(),"a_b");
matchers=m1.getMatchers();
Assert.assertEquals(matchers.size(),2);
Assert.assertEquals(matchers.get(0).size(),2);
Assert.assertEquals(matchers.get(0).get(0),"c");
Assert.assertEquals(matchers.get(0).get(1),"d");
Assert.assertEquals(matchers.get(1).size(),1);
Assert.assertEquals(matchers.get(1).get(0),"c.d");
m1=new Metric("a_b.c.d.e",true,false);
Assert.assertEquals(m1.getJmxBeanKeyName(),"a_b");
matchers=m1.getMatchers();
Assert.assertEquals(matchers.size(),4);
Assert.assertEquals(matchers.get(0).size(),3);
Assert.assertEquals(matchers.get(0).get(1),"d");
Assert.assertEquals(matchers.get(0).get(2),"e");
Assert.assertEquals(matchers.get(2).size(),2);
Assert.assertEquals(matchers.get(2).get(0),"c.d");
Assert.assertEquals(matchers.get(2).get(1),"e");
Assert.assertEquals(matchers.get(3).size(),1);
Assert.assertEquals(matchers.get(3).get(0),"c.d.e");
}
Class: org.apache.ambari.view.utils.ViewUserLocalTest InternalCallVerifier IdentityVerifier InternalCallVerifier IdentityVerifier InternalCallVerifier IdentityVerifier Class: org.apache.ambari.view.utils.ambari.RemoteClusterTest InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier instanceProperties=new HashMap();
instanceProperties.put(AmbariApi.AMBARI_SERVER_URL_INSTANCE_PROPERTY,AMBARI_CLUSTER_REST_URL);
instanceProperties.put(AmbariApi.AMBARI_SERVER_USERNAME_INSTANCE_PROPERTY,"admin");
instanceProperties.put(AmbariApi.AMBARI_SERVER_PASSWORD_INSTANCE_PROPERTY,"admin");
expect(viewContext.getProperties()).andReturn(instanceProperties).anyTimes();
replay(viewContext);
AmbariApi ambariApi=new AmbariApi(viewContext);
Cluster cluster=ambariApi.getRemoteCluster();
assertNotNull(cluster);
assertEquals(cluster.getName(),"c1");
}
InternalCallVerifier NullVerifier instanceProperties=new HashMap();
expect(viewContext.getProperties()).andReturn(instanceProperties).anyTimes();
replay(viewContext);
AmbariApi ambariApi=new AmbariApi(viewContext);
Cluster cluster=ambariApi.getRemoteCluster();
assertNull(cluster);
}
InternalCallVerifier EqualityVerifier )anyObject())).andAnswer(new IAnswer(){
@Override public InputStream answer() throws Throwable {
desiredConfigPolls[0]+=1;
return new ByteArrayInputStream(desiredConfigsString.getBytes());
}
}
).anyTimes();
expect(urlStreamProvider.readFrom(eq(AMBARI_CLUSTER_REST_URL + "/configurations?(type=test-site&tag=TAG)"),eq("GET"),(String)isNull(),(Map)anyObject())).andAnswer(new IAnswer(){
@Override public InputStream answer() throws Throwable {
testConfigPolls[0]+=1;
return new ByteArrayInputStream(configurationString.getBytes());
}
}
).anyTimes();
replay(urlStreamProvider);
RemoteCluster cluster=new RemoteCluster(AMBARI_CLUSTER_REST_URL,urlStreamProvider);
PassiveExpiringMap cache=new PassiveExpiringMap(10000L);
cluster.configurationCache=cache;
String value=cluster.getConfigurationValue("test-site","test.property.name");
assertEquals(value,"test property value");
assertEquals(desiredConfigPolls[0],1);
assertEquals(testConfigPolls[0],1);
value=cluster.getConfigurationValue("test-site","test.property.name");
assertEquals(value,"test property value");
assertEquals(desiredConfigPolls[0],1);
assertEquals(testConfigPolls[0],1);
cache.clear();
value=cluster.getConfigurationValue("test-site","test.property.name");
assertEquals(value,"test property value");
assertEquals(desiredConfigPolls[0],2);
assertEquals(testConfigPolls[0],2);
}
Class: org.apache.ambari.view.utils.ambari.ServicesTest InternalCallVerifier EqualityVerifier ());
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
Cluster cluster=createNiceMock(Cluster.class);
expect(ambariApi.isClusterAssociated()).andReturn(true).anyTimes();
setClusterExpectationWithEmptyWebappConfig(cluster,"HTTP_ONLY");
expect(ambariApi.getCluster()).andReturn(cluster).anyTimes();
Services services=new Services(ambariApi,viewContext);
replayAll();
assertEquals("http://" + RM_URL1_HOST + ":8088",services.getRMUrl());
reset(cluster);
setClusterExpectationWithEmptyWebappConfig(cluster,"HTTPS_ONLY");
replay(cluster);
assertEquals("https://" + RM_URL1_HOST + ":8090",services.getRMUrl());
}
InternalCallVerifier EqualityVerifier ());
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
Cluster cluster=createNiceMock(Cluster.class);
Services services=new Services(ambariApi,viewContext);
expect(ambariApi.isClusterAssociated()).andReturn(true).anyTimes();
setClusterExpectation(cluster,"HTTP_ONLY");
expect(ambariApi.getCluster()).andReturn(cluster).anyTimes();
replayAll();
assertEquals(HTTP_RM_URL1,services.getTimelineServerUrl());
reset(cluster);
setClusterExpectation(cluster,"HTTPS_ONLY");
replay(cluster);
assertEquals(HTTPS_RM_URL2,services.getTimelineServerUrl());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier map=new HashMap<>();
map.put("yarn.resourcemanager.url",HTTP_RM_URL1);
ViewContext viewContext=getViewContext(map);
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
expect(ambariApi.isClusterAssociated()).andReturn(false);
replay(viewContext);
Services services=new Services(ambariApi,viewContext);
assertEquals(HTTP_RM_URL1,services.getRMUrl());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier map=new HashMap<>();
map.put("yarn.resourcemanager.url",HTTP_RM_URL1 + ", " + HTTP_RM_URL2);
ViewContext viewContext=getViewContext(map);
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
URLStreamProvider urlStreamProvider=createNiceMock(URLStreamProvider.class);
InputStream inputStream=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"STANDBY\"}}");
expect(ambariApi.isClusterAssociated()).andReturn(false);
expect(viewContext.getURLStreamProvider()).andReturn(urlStreamProvider).anyTimes();
expect(urlStreamProvider.readFrom(eq(HTTP_RM_URL1 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStream);
InputStream inputStreamActive=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"ACTIVE\"}}");
expect(urlStreamProvider.readFrom(eq(HTTP_RM_URL2 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStreamActive);
replayAll();
Services services=new Services(ambariApi,viewContext);
assertEquals(HTTP_RM_URL2,services.getRMUrl());
verify(urlStreamProvider);
}
InternalCallVerifier EqualityVerifier ());
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
Cluster cluster=createNiceMock(Cluster.class);
URLStreamProvider urlStreamProvider=createNiceMock(URLStreamProvider.class);
Services services=new Services(ambariApi,viewContext);
InputStream inputStream=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"ACTIVE\"}}");
expect(ambariApi.isClusterAssociated()).andReturn(true).anyTimes();
setClusterExpectationInHA(cluster,"HTTP_ONLY");
expect(ambariApi.getCluster()).andReturn(cluster).anyTimes();
expect(viewContext.getURLStreamProvider()).andReturn(urlStreamProvider).anyTimes();
expect(urlStreamProvider.readFrom(eq(HTTP_RM_URL1 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStream);
replayAll();
assertEquals(HTTP_RM_URL1,services.getRMUrl());
reset(cluster,urlStreamProvider);
setClusterExpectationInHA(cluster,"HTTP_ONLY");
inputStream=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"ACTIVE\"}}");
expect(urlStreamProvider.readFrom(eq(HTTP_RM_URL1 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andThrow(new IOException());
expect(urlStreamProvider.readFrom(eq(HTTP_RM_URL2 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStream);
replay(cluster,urlStreamProvider);
assertEquals(HTTP_RM_URL2,services.getRMUrl());
reset(cluster,urlStreamProvider);
setClusterExpectationInHA(cluster,"HTTPS_ONLY");
inputStream=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"ACTIVE\"}}");
expect(urlStreamProvider.readFrom(eq(HTTPS_RM_URL1 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStream);
replay(cluster,urlStreamProvider);
assertEquals(HTTPS_RM_URL1,services.getRMUrl());
reset(cluster,urlStreamProvider);
setClusterExpectationInHA(cluster,"HTTPS_ONLY");
inputStream=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"ACTIVE\"}}");
expect(urlStreamProvider.readFrom(eq(HTTPS_RM_URL1 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andThrow(new IOException());
expect(urlStreamProvider.readFrom(eq(HTTPS_RM_URL2 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStream);
replay(cluster,urlStreamProvider);
assertEquals(HTTPS_RM_URL2,services.getRMUrl());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier map=new HashMap<>();
map.put("yarn.resourcemanager.url",HTTP_RM_URL1 + ", " + HTTP_RM_URL2);
ViewContext viewContext=getViewContext(map);
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
URLStreamProvider urlStreamProvider=createNiceMock(URLStreamProvider.class);
InputStream inputStream=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"ACTIVE\"}}");
expect(ambariApi.isClusterAssociated()).andReturn(false);
expect(viewContext.getURLStreamProvider()).andReturn(urlStreamProvider);
expect(urlStreamProvider.readFrom(eq(HTTP_RM_URL1 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStream);
replayAll();
Services services=new Services(ambariApi,viewContext);
assertEquals(HTTP_RM_URL1,services.getRMUrl());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier map=new HashMap<>();
map.put("yarn.resourcemanager.url",HTTP_RM_URL1 + ", " + HTTP_RM_URL2);
ViewContext viewContext=getViewContext(map);
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
URLStreamProvider urlStreamProvider=createNiceMock(URLStreamProvider.class);
InputStream inputStream=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"ACTIVE\"}}");
expect(ambariApi.isClusterAssociated()).andReturn(false);
expect(viewContext.getURLStreamProvider()).andReturn(urlStreamProvider).anyTimes();
expect(urlStreamProvider.readFrom(eq(HTTP_RM_URL1 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andThrow(new IOException());
expect(urlStreamProvider.readFrom(eq(HTTP_RM_URL2 + RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStream);
replayAll();
Services services=new Services(ambariApi,viewContext);
assertEquals(HTTP_RM_URL2,services.getRMUrl());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier map=new HashMap<>();
map.put("yarn.timeline-server.url",HTTP_RM_URL1);
ViewContext viewContext=getViewContext(map);
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
expect(ambariApi.isClusterAssociated()).andReturn(false);
replay(viewContext);
Services services=new Services(ambariApi,viewContext);
assertEquals(HTTP_RM_URL1,services.getTimelineServerUrl());
}
InternalCallVerifier EqualityVerifier ());
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
Cluster cluster=createNiceMock(Cluster.class);
URLStreamProvider urlStreamProvider=createNiceMock(URLStreamProvider.class);
expect(ambariApi.isClusterAssociated()).andReturn(true).anyTimes();
setClusterExpectationInHAWithEmptyWebappConfig(cluster,"HTTP_ONLY");
expect(ambariApi.getCluster()).andReturn(cluster).anyTimes();
Services services=new Services(ambariApi,viewContext);
InputStream inputStream=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"ACTIVE\"}}");
expect(viewContext.getURLStreamProvider()).andReturn(urlStreamProvider).anyTimes();
expect(urlStreamProvider.readFrom(eq("http://" + RM_URL1_HOST + ":8088"+ RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStream);
replayAll();
assertEquals("http://" + RM_URL1_HOST + ":8088",services.getRMUrl());
reset(cluster,urlStreamProvider);
setClusterExpectationInHAWithEmptyWebappConfig(cluster,"HTTPS_ONLY");
inputStream=IOUtils.toInputStream("{\"clusterInfo\": {\"haState\": \"ACTIVE\"}}");
expect(urlStreamProvider.readFrom(eq("https://" + RM_URL1_HOST + ":8090"+ RM_INFO_API_ENDPOINT),eq("GET"),anyString(),EasyMock.>anyObject())).andReturn(inputStream);
replay(cluster,urlStreamProvider);
assertEquals("https://" + RM_URL1_HOST + ":8090",services.getRMUrl());
}
InternalCallVerifier EqualityVerifier ());
AmbariApi ambariApi=createNiceMock(AmbariApi.class);
Cluster cluster=createNiceMock(Cluster.class);
expect(ambariApi.isClusterAssociated()).andReturn(true).anyTimes();
setClusterExpectation(cluster,"HTTP_ONLY");
expect(ambariApi.getCluster()).andReturn(cluster).anyTimes();
replayAll();
Services services=new Services(ambariApi,viewContext);
assertEquals(HTTP_RM_URL1,services.getRMUrl());
reset(cluster);
setClusterExpectation(cluster,"HTTPS_ONLY");
replay(cluster);
assertEquals(HTTPS_RM_URL2,services.getRMUrl());
reset(cluster);
setClusterExpectation(cluster,"HTTPS_ONLY_XYZ");
replay(cluster);
assertEquals(HTTP_RM_URL1,services.getRMUrl());
}
Class: org.apache.hadoop.metrics2.sink.SqlServerSinkTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier BooleanVerifier Class: org.apache.hadoop.metrics2.sink.kafka.KafkaTimelineMetricsReporterTest InternalCallVerifier BooleanVerifier Class: org.apache.hadoop.metrics2.sink.timeline.HadoopTimelineMetricsSinkTest APIUtilityVerifier InternalCallVerifier EqualityVerifier capturedMetrics=new ArrayList();
sink.emitMetrics((TimelineMetrics)anyObject());
expectLastCall().andStubAnswer(new IAnswer(){
@Override public Object answer() throws Throwable {
capturedMetrics.add((TimelineMetrics)EasyMock.getCurrentArguments()[0]);
return null;
}
}
);
replay(conf,sink,record,metric);
sink.init(conf);
sink.putMetrics(record);
sink.putMetrics(record);
sink.putMetrics(record);
sink.putMetrics(record);
sink.putMetrics(record);
sink.putMetrics(record);
verify(conf,sink,record,metric);
Assert.assertEquals(2,capturedMetrics.size());
Iterator metricsIterator=capturedMetrics.iterator();
TimelineMetric timelineMetric1=metricsIterator.next().getMetrics().get(0);
Assert.assertEquals(2,timelineMetric1.getMetricValues().size());
Iterator timestamps=timelineMetric1.getMetricValues().keySet().iterator();
Assert.assertEquals(now,timestamps.next());
Assert.assertEquals(new Long(now + 100l),timestamps.next());
Iterator values=timelineMetric1.getMetricValues().values().iterator();
Assert.assertEquals(new Double(1.0),values.next());
Assert.assertEquals(new Double(3.0),values.next());
TimelineMetric timelineMetric2=metricsIterator.next().getMetrics().get(0);
Assert.assertEquals(2,timelineMetric2.getMetricValues().size());
timestamps=timelineMetric2.getMetricValues().keySet().iterator();
Assert.assertEquals(new Long(now + 200l),timestamps.next());
Assert.assertEquals(new Long(now + 300l),timestamps.next());
values=timelineMetric2.getMetricValues().values().iterator();
Assert.assertEquals(new Double(5.0),values.next());
Assert.assertEquals(new Double(6.0),values.next());
}
Class: org.apache.hadoop.metrics2.sink.timeline.cache.TimelineMetricsCacheTest InternalCallVerifier EqualityVerifier (){
{
put(1L,10.0);
}
}
,DEFAULT_START_TIME);
timelineMetricsCache.putTimelineMetric(metric,true);
metric=createTimelineMetric(new TreeMap(){
{
put(2L,10.0);
put(3L,20.0);
put(4L,30.0);
}
}
,DEFAULT_START_TIME + 2 * TimelineMetricsCache.MAX_EVICTION_TIME_MILLIS);
timelineMetricsCache.putTimelineMetric(metric,true);
TimelineMetric cachedMetric=timelineMetricsCache.getTimelineMetric(METRIC_NAME);
assertEquals(0,cachedMetric.getMetricValues().get(1L),delta);
assertEquals(0,cachedMetric.getMetricValues().get(2L),delta);
assertEquals(10,cachedMetric.getMetricValues().get(3L),delta);
assertEquals(10,cachedMetric.getMetricValues().get(4L),delta);
metric=createTimelineMetric(new TreeMap(){
{
put(5L,100.0);
put(6L,120.0);
put(7L,230.0);
}
}
,DEFAULT_START_TIME + 3 * TimelineMetricsCache.MAX_EVICTION_TIME_MILLIS);
timelineMetricsCache.putTimelineMetric(metric,true);
metric=createTimelineMetric(new TreeMap(){
{
put(8L,300.0);
}
}
,DEFAULT_START_TIME + 5 * TimelineMetricsCache.MAX_EVICTION_TIME_MILLIS);
timelineMetricsCache.putTimelineMetric(metric,true);
cachedMetric=timelineMetricsCache.getTimelineMetric(METRIC_NAME);
assertEquals(70,cachedMetric.getMetricValues().get(5L),delta);
assertEquals(20,cachedMetric.getMetricValues().get(6L),delta);
assertEquals(110,cachedMetric.getMetricValues().get(7L),delta);
assertEquals(70,cachedMetric.getMetricValues().get(8L),delta);
}
Class: org.apache.hadoop.yarn.server.applicationhistoryservice.TestApplicationHistoryClientService APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier appReport=response.getApplicationList();
Assert.assertNotNull(appReport);
Assert.assertEquals(appId,appReport.get(0).getApplicationId());
Assert.assertEquals(appId1,appReport.get(1).getApplicationId());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier attemptReports=response.getApplicationAttemptList();
Assert.assertNotNull(attemptReports);
Assert.assertEquals(appAttemptId,attemptReports.get(0).getApplicationAttemptId());
Assert.assertEquals(appAttemptId1,attemptReports.get(1).getApplicationAttemptId());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier containers=response.getContainerList();
Assert.assertNotNull(containers);
Assert.assertEquals(containerId,containers.get(1).getContainerId());
Assert.assertEquals(containerId1,containers.get(0).getContainerId());
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.TestApplicationHistoryManagerImpl APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier IgnoredMethod HybridVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.TestApplicationHistoryServer InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier TestInitializer InternalCallVerifier NullVerifier HybridVerifier \n" + " \n" + " hbase.defaults.for.version.skip \n"+ " true \n"+ " "+ " "+ " hbase.zookeeper.quorum \n"+ " localhost \n"+ " "+ " ");
FileUtils.writeStringToFile(amsSite,"\n" + " \n" + " test \n"+ " testReady \n"+ " \n"+ " \n"+ " timeline.metrics.host.aggregator.hourly.disabled \n"+ " true \n"+ " \n"+ " Disable host based hourly aggregations.\n"+ " \n"+ " \n"+ " \n"+ " timeline.metrics.host.aggregator.minute.disabled \n"+ " true \n"+ " \n"+ " Disable host based minute aggregations.\n"+ " \n"+ " \n"+ " \n"+ " timeline.metrics.cluster.aggregator.hourly.disabled \n"+ " true \n"+ " \n"+ " Disable cluster based hourly aggregations.\n"+ " \n"+ " \n"+ " \n"+ " timeline.metrics.cluster.aggregator.minute.disabled \n"+ " true \n"+ " \n"+ " Disable cluster based minute aggregations.\n"+ " \n"+ " "+ " ");
ClassLoader currentClassLoader=Thread.currentThread().getContextClassLoader();
URLClassLoader urlClassLoader=null;
try {
urlClassLoader=new URLClassLoader(new URL[]{folder.getRoot().toURI().toURL()},currentClassLoader);
}
catch ( MalformedURLException e) {
e.printStackTrace();
}
Thread.currentThread().setContextClassLoader(urlClassLoader);
metricsConf=new Configuration(false);
metricsConf.addResource(Thread.currentThread().getContextClassLoader().getResource(METRICS_SITE_CONFIGURATION_FILE).toURI().toURL());
assertNotNull(metricsConf.get("test"));
}
Class: org.apache.hadoop.yarn.server.applicationhistoryservice.TestFileSystemApplicationHistoryStore InternalCallVerifier BooleanVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.TestMemoryApplicationHistoryStore APIUtilityVerifier IterativeVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier IterativeVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier IterativeVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier NullVerifier HybridVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.loadsimulator.data.TestAppMetrics InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.loadsimulator.data.TestMetric InternalCallVerifier EqualityVerifier ConditionMatcher HybridVerifier InternalCallVerifier EqualityVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.loadsimulator.net.TestRestMetricsSender InternalCallVerifier EqualityVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.loadsimulator.util.TestRandomMetricsProvider InternalCallVerifier BooleanVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.loadsimulator.util.TestTimeStampProvider InternalCallVerifier EqualityVerifier InternalCallVerifier ConditionMatcher Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.timeline.ITPhoenixHBaseAccessor APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier aggMap=new HashMap();
long startTime=System.currentTimeMillis();
int min_5=5 * 60 * 1000;
long ctime=startTime - min_5;
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
hdb.saveHostAggregateRecords(aggMap,METRICS_AGGREGATE_MINUTE_TABLE_NAME);
long endTime=ctime + min_5;
boolean success=aggregator.doWork(startTime,endTime);
assertTrue(success);
Condition condition=new DefaultCondition(Collections.singletonList("disk_used"),Collections.singletonList("test_host"),"test_app",null,startTime,endTime,Precision.HOURS,null,true);
TimelineMetrics timelineMetrics=hdb.getMetricRecords(condition,singletonValueFunctionMap("disk_used"));
assertEquals(1,timelineMetrics.getMetrics().size());
TimelineMetric metric=timelineMetrics.getMetrics().get(0);
assertEquals("disk_used",metric.getMetricName());
assertEquals("test_host",metric.getHostName());
assertEquals(1,metric.getMetricValues().size());
Iterator> iterator=metric.getMetricValues().entrySet().iterator();
assertEquals(0.75,iterator.next().getValue(),0.00001);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier records=new HashMap();
records.put(createEmptyTimelineClusterMetric(ctime),new MetricClusterAggregate(4.0,2,0.0,4.0,0.0));
records.put(createEmptyTimelineClusterMetric(ctime+=minute),new MetricClusterAggregate(4.0,2,0.0,4.0,0.0));
records.put(createEmptyTimelineClusterMetric(ctime+=minute),new MetricClusterAggregate(4.0,2,0.0,4.0,0.0));
records.put(createEmptyTimelineClusterMetric(ctime+=minute),new MetricClusterAggregate(4.0,2,0.0,4.0,0.0));
hdb.saveClusterAggregateRecords(records);
boolean success=agg.doWork(startTime,ctime + minute);
assertTrue(success);
Condition condition=new DefaultCondition(Collections.singletonList("disk_used"),null,null,null,startTime,ctime + minute,Precision.HOURS,null,true);
TimelineMetrics timelineMetrics=hdb.getAggregateMetricRecords(condition,singletonValueFunctionMap("disk_used"));
assertEquals(1,timelineMetrics.getMetrics().size());
TimelineMetric metric=timelineMetrics.getMetrics().get(0);
assertEquals("disk_used",metric.getMetricName());
assertEquals("test_app",metric.getAppId());
assertEquals(1,metric.getMetricValues().size());
assertEquals(2.0,metric.getMetricValues().values().iterator().next(),0.00001);
}
APIUtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier > iterator=metric.getMetricValues().entrySet().iterator();
assertEquals(1.5,iterator.next().getValue(),0.00001);
}
Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.timeline.PhoenixHBaseAccessorTest InternalCallVerifier EqualityVerifier metricNames=new LinkedList<>();
List hostnames=new LinkedList<>();
Map> metricFunctions=new HashMap<>();
PowerMock.mockStatic(PhoenixTransactSQL.class);
PreparedStatement preparedStatementMock=EasyMock.createNiceMock(PreparedStatement.class);
Condition condition=new DefaultCondition(metricNames,hostnames,"appid","instanceid",123L,234L,Precision.SECONDS,10,true);
EasyMock.expect(PhoenixTransactSQL.prepareGetMetricsSqlStmt(null,condition)).andReturn(preparedStatementMock).once();
ResultSet rsMock=EasyMock.createNiceMock(ResultSet.class);
EasyMock.expect(preparedStatementMock.executeQuery()).andReturn(rsMock);
PowerMock.replayAll();
EasyMock.replay(preparedStatementMock,rsMock);
TimelineMetrics tml=accessor.getMetricRecords(condition,metricFunctions);
Condition condition2=new DefaultCondition(metricNames,hostnames,"appid","instanceid",234L,123L,Precision.SECONDS,10,true);
TimelineMetrics tml2=accessor.getMetricRecords(condition2,metricFunctions);
assertEquals(0,tml2.getMetrics().size());
PowerMock.verifyAll();
EasyMock.verify(preparedStatementMock,rsMock);
}
InternalCallVerifier EqualityVerifier metricNames=new LinkedList<>();
List hostnames=new LinkedList<>();
Map> metricFunctions=new HashMap<>();
PowerMock.mockStatic(PhoenixTransactSQL.class);
PreparedStatement preparedStatementMock=EasyMock.createNiceMock(PreparedStatement.class);
Condition condition=new DefaultCondition(metricNames,hostnames,"appid","instanceid",123L,234L,Precision.SECONDS,10,true);
EasyMock.expect(PhoenixTransactSQL.prepareGetMetricsSqlStmt(null,condition)).andReturn(preparedStatementMock).once();
ResultSet rsMock=EasyMock.createNiceMock(ResultSet.class);
RuntimeException runtimeException=EasyMock.createNiceMock(RuntimeException.class);
IOException io=EasyMock.createNiceMock(IOException.class);
EasyMock.expect(preparedStatementMock.executeQuery()).andThrow(runtimeException);
EasyMock.expect(runtimeException.getCause()).andReturn(io).atLeastOnce();
StackTraceElement stackTrace[]=new StackTraceElement[]{new StackTraceElement("TimeRange","method","file",1)};
EasyMock.expect(io.getStackTrace()).andReturn(stackTrace).atLeastOnce();
PowerMock.replayAll();
EasyMock.replay(preparedStatementMock,rsMock,io,runtimeException);
TimelineMetrics tml=accessor.getMetricRecords(condition,metricFunctions);
assertEquals(0,tml.getMetrics().size());
PowerMock.verifyAll();
EasyMock.verify(preparedStatementMock,rsMock,io,runtimeException);
}
Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.timeline.TestMetricHostAggregate InternalCallVerifier ConditionMatcher InternalCallVerifier ConditionMatcher Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.timeline.TestPhoenixTransactSQL InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetMetricsSqlStmt(connection,condition);
String stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_RECORD"));
Assert.assertEquals(Precision.SECONDS,condition.getPrecision());
verify(connection,preparedStatement);
reset(connection,preparedStatement);
startTime=endTime - PhoenixTransactSQL.HOUR * 2 / 1000;
condition=new DefaultCondition(Arrays.asList("cpu_user","mem_free"),Collections.singletonList("h1"),"a1","i1",startTime,endTime,null,null,false);
connection=createNiceMock(Connection.class);
preparedStatement=createNiceMock(PreparedStatement.class);
stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetMetricsSqlStmt(connection,condition);
stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_RECORD"));
Assert.assertEquals(Precision.SECONDS,condition.getPrecision());
verify(connection,preparedStatement);
startTime=endTime - PhoenixTransactSQL.DAY / 1000;
condition=new DefaultCondition(Arrays.asList("cpu_user","mem_free"),Collections.singletonList("h1"),"a1","i1",startTime,endTime,null,null,false);
connection=createNiceMock(Connection.class);
preparedStatement=createNiceMock(PreparedStatement.class);
stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetMetricsSqlStmt(connection,condition);
stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_RECORD_MINUTE"));
Assert.assertEquals(Precision.MINUTES,condition.getPrecision());
verify(connection,preparedStatement);
startTime=endTime - PhoenixTransactSQL.DAY * 30 / 1000;
condition=new DefaultCondition(Arrays.asList("cpu_user","mem_free"),Collections.singletonList("h1"),"a1","i1",startTime,endTime,null,null,false);
connection=createNiceMock(Connection.class);
preparedStatement=createNiceMock(PreparedStatement.class);
stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetMetricsSqlStmt(connection,condition);
stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_RECORD_HOURLY"));
Assert.assertEquals(Precision.HOURS,condition.getPrecision());
verify(connection,preparedStatement);
startTime=endTime - PhoenixTransactSQL.DAY * 30 * 2 / 1000;
condition=new DefaultCondition(Arrays.asList("cpu_user","mem_free"),Collections.singletonList("h1"),"a1","i1",startTime,endTime,null,null,false);
connection=createNiceMock(Connection.class);
preparedStatement=createNiceMock(PreparedStatement.class);
stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetMetricsSqlStmt(connection,condition);
stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_RECORD_DAILY"));
Assert.assertEquals(Precision.DAYS,condition.getPrecision());
verify(connection,preparedStatement);
}
InternalCallVerifier BooleanVerifier stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetAggregateSqlStmt(connection,condition);
String stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_AGGREGATE_HOURLY"));
verify(connection,preparedStatement);
}
InternalCallVerifier BooleanVerifier stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
expect(preparedStatement.getParameterMetaData()).andReturn(parameterMetaData).once();
expect(parameterMetaData.getParameterCount()).andReturn(6).once();
replay(connection,preparedStatement,parameterMetaData);
PhoenixTransactSQL.prepareGetLatestMetricSqlStmt(connection,condition);
String stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_RECORD"));
Assert.assertTrue(stmt.contains("JOIN"));
verify(connection,preparedStatement,parameterMetaData);
}
InternalCallVerifier BooleanVerifier stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetMetricsSqlStmt(connection,condition);
String stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_RECORD_HOURLY"));
verify(connection,preparedStatement);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier emptyList(),Collections.singletonList("h1"),"a1","i1",1407959718L,1407959918L,null,null,false);
preparedClause=condition.getConditionClause().toString();
expectedClause=" HOSTNAME = ? AND " + "APP_ID = ? AND INSTANCE_ID = ? AND SERVER_TIME >= ? AND SERVER_TIME < ?";
Assert.assertNotNull(preparedClause);
Assert.assertEquals(expectedClause,preparedClause);
condition=new DefaultCondition(null,Collections.singletonList("h1"),"a1","i1",1407959718L,1407959918L,null,null,false);
preparedClause=condition.getConditionClause().toString();
expectedClause=" HOSTNAME = ? AND " + "APP_ID = ? AND INSTANCE_ID = ? AND SERVER_TIME >= ? AND SERVER_TIME < ?";
Assert.assertNotNull(preparedClause);
Assert.assertEquals(expectedClause,preparedClause);
condition=new DefaultCondition(Arrays.asList("some=%.metric"),Collections.singletonList("h1"),"a1","i1",1407959718L,1407959918L,null,null,false);
preparedClause=condition.getConditionClause().toString();
expectedClause="(METRIC_NAME LIKE ?) AND HOSTNAME = ? AND " + "APP_ID = ? AND INSTANCE_ID = ? AND SERVER_TIME >= ? AND SERVER_TIME < ?";
Assert.assertNotNull(preparedClause);
Assert.assertEquals(expectedClause,preparedClause);
condition=new DefaultCondition(Arrays.asList("some=%.metric1","some=%.metric2","some=%.metric3"),Collections.singletonList("h1"),"a1","i1",1407959718L,1407959918L,null,null,false);
preparedClause=condition.getConditionClause().toString();
expectedClause="(METRIC_NAME LIKE ? OR METRIC_NAME LIKE ? OR METRIC_NAME LIKE ?) AND HOSTNAME = ? AND " + "APP_ID = ? AND INSTANCE_ID = ? AND SERVER_TIME >= ? AND SERVER_TIME < ?";
Assert.assertNotNull(preparedClause);
Assert.assertEquals(expectedClause,preparedClause);
}
InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier BooleanVerifier stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetAggregateSqlStmt(connection,condition);
String stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_AGGREGATE"));
verify(connection,preparedStatement);
}
InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetAggregateSqlStmt(connection,condition);
String stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_AGGREGATE"));
Assert.assertEquals(Precision.SECONDS,condition.getPrecision());
verify(connection,preparedStatement);
startTime=endTime - PhoenixTransactSQL.DAY / 1000;
condition=new DefaultCondition(Arrays.asList("cpu_user","mem_free"),Collections.singletonList("h1"),"a1","i1",startTime,endTime,null,null,false);
connection=createNiceMock(Connection.class);
preparedStatement=createNiceMock(PreparedStatement.class);
stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetAggregateSqlStmt(connection,condition);
stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_AGGREGATE"));
Assert.assertEquals(Precision.MINUTES,condition.getPrecision());
verify(connection,preparedStatement);
startTime=endTime - PhoenixTransactSQL.DAY * 30 / 1000;
condition=new DefaultCondition(Arrays.asList("cpu_user","mem_free"),Collections.singletonList("h1"),"a1","i1",startTime,endTime,null,null,false);
connection=createNiceMock(Connection.class);
preparedStatement=createNiceMock(PreparedStatement.class);
stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetAggregateSqlStmt(connection,condition);
stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_AGGREGATE_HOURLY"));
Assert.assertEquals(Precision.HOURS,condition.getPrecision());
verify(connection,preparedStatement);
startTime=endTime - PhoenixTransactSQL.DAY * 30 * 2 / 1000;
condition=new DefaultCondition(Arrays.asList("cpu_user","mem_free"),Collections.singletonList("h1"),"a1","i1",startTime,endTime,null,null,false);
connection=createNiceMock(Connection.class);
preparedStatement=createNiceMock(PreparedStatement.class);
stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetAggregateSqlStmt(connection,condition);
stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_AGGREGATE_DAILY"));
Assert.assertEquals(Precision.DAYS,condition.getPrecision());
verify(connection,preparedStatement);
}
InternalCallVerifier BooleanVerifier stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
expect(preparedStatement.getParameterMetaData()).andReturn(parameterMetaData).anyTimes();
expect(parameterMetaData.getParameterCount()).andReturn(6).anyTimes();
replay(connection,preparedStatement,parameterMetaData);
PhoenixTransactSQL.setSortMergeJoinEnabled(true);
PhoenixTransactSQL.prepareGetLatestMetricSqlStmt(connection,condition);
String stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("/*+ USE_SORT_MERGE_JOIN NO_CACHE */"));
}
InternalCallVerifier BooleanVerifier stmtCapture=new Capture();
expect(connection.prepareStatement(EasyMock.and(EasyMock.anyString(),EasyMock.capture(stmtCapture)))).andReturn(preparedStatement);
replay(connection,preparedStatement);
PhoenixTransactSQL.prepareGetMetricsSqlStmt(connection,condition);
String stmt=stmtCapture.getValue();
Assert.assertTrue(stmt.contains("FROM METRIC_RECORD_MINUTE"));
verify(connection,preparedStatement);
}
Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.timeline.aggregators.AbstractTimelineAggregatorTest InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.timeline.aggregators.ITClusterAggregator APIUtilityVerifier IterativeVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier (){
{
put(1431372311811l,1.0);
put(1431372321811l,1.0);
put(1431372331811l,1.0);
put(1431372341811l,1.0);
put(1431372351811l,1.0);
put(1431372361811l,1.0);
put(1431372371810l,1.0);
}
}
);
TimelineMetric metric2=new TimelineMetric();
metric2.setMetricName("yarn.ClusterMetrics.NumActiveNMs");
metric2.setAppId("resourcemanager");
metric2.setHostName("h1");
metric2.setStartTime(1431372381810l);
metric2.setMetricValues(new TreeMap(){
{
put(1431372381810l,1.0);
put(1431372391811l,1.0);
put(1431372401811l,1.0);
put(1431372411811l,1.0);
put(1431372421811l,1.0);
put(1431372431811l,1.0);
put(1431372441810l,1.0);
}
}
);
TimelineMetrics metrics=new TimelineMetrics();
metrics.setMetrics(Collections.singletonList(metric1));
insertMetricRecords(conn,metrics,1431372371810l);
metrics.setMetrics(Collections.singletonList(metric2));
insertMetricRecords(conn,metrics,1431372441810l);
long startTime=1431372055000l;
long endTime=1431372655000l;
agg.doWork(startTime,endTime);
Condition condition=new DefaultCondition(null,null,null,null,startTime,endTime,null,null,true);
condition.setStatement(String.format(GET_CLUSTER_AGGREGATE_SQL,PhoenixTransactSQL.getNaiveTimeRangeHint(startTime,NATIVE_TIME_RANGE_DELTA),METRICS_CLUSTER_AGGREGATE_TABLE_NAME));
PreparedStatement pstmt=PhoenixTransactSQL.prepareGetMetricsSqlStmt(conn,condition);
ResultSet rs=pstmt.executeQuery();
int recordCount=0;
while (rs.next()) {
TimelineClusterMetric currentMetric=metricReader.fromResultSet(rs);
MetricClusterAggregate currentHostAggregate=readHelper.getMetricClusterAggregateFromResultSet(rs);
if ("yarn.ClusterMetrics.NumActiveNMs".equals(currentMetric.getMetricName())) {
assertEquals(1,currentHostAggregate.getNumberOfHosts());
assertEquals(1.0,currentHostAggregate.getMax());
assertEquals(1.0,currentHostAggregate.getMin());
assertEquals(1.0,currentHostAggregate.getSum());
recordCount++;
}
else {
fail("Unexpected entry");
}
}
Assert.assertEquals(5,recordCount);
}
APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier IterativeVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier APIUtilityVerifier IterativeVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier APIUtilityVerifier IterativeVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.timeline.aggregators.ITMetricAggregator APIUtilityVerifier IterativeVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier aggMap=new HashMap();
int min_5=5 * 60 * 1000;
long ctime=startTime - min_5;
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
hdb.saveHostAggregateRecords(aggMap,METRICS_AGGREGATE_MINUTE_TABLE_NAME);
long endTime=ctime + min_5;
boolean success=aggregator.doWork(startTime,endTime);
assertTrue(success);
Condition condition=new DefaultCondition(null,null,null,null,startTime,endTime,null,null,true);
condition.setStatement(String.format(GET_METRIC_AGGREGATE_ONLY_SQL,PhoenixTransactSQL.getNaiveTimeRangeHint(startTime,NATIVE_TIME_RANGE_DELTA),METRICS_AGGREGATE_HOURLY_TABLE_NAME));
PreparedStatement pstmt=PhoenixTransactSQL.prepareGetMetricsSqlStmt(conn,condition);
ResultSet rs=pstmt.executeQuery();
while (rs.next()) {
TimelineMetric currentMetric=readHelper.getTimelineMetricKeyFromResultSet(rs);
MetricHostAggregate currentHostAggregate=readHelper.getMetricHostAggregateFromResultSet(rs);
if ("disk_used".equals(currentMetric.getMetricName())) {
assertEquals(2.0,currentHostAggregate.getMax());
assertEquals(0.0,currentHostAggregate.getMin());
assertEquals(12 * 20,currentHostAggregate.getNumberOfSamples());
assertEquals(12 * 15.0,currentHostAggregate.getSum());
assertEquals(15.0 / 20,currentHostAggregate.getAvg());
}
}
}
APIUtilityVerifier IterativeVerifier BranchVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier APIUtilityVerifier IterativeVerifier BranchVerifier UtilityVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier APIUtilityVerifier IterativeVerifier BranchVerifier InternalCallVerifier BooleanVerifier EqualityVerifier HybridVerifier aggMap=new HashMap();
int min_5=5 * 60 * 1000;
long ctime=startTime - min_5;
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
aggMap.put(createEmptyTimelineMetric(ctime+=min_5),expectedAggregate);
hdb.saveHostAggregateRecords(aggMap,METRICS_AGGREGATE_HOURLY_TABLE_NAME);
long endTime=ctime + min_5;
boolean success=aggregator.doWork(startTime,endTime);
assertTrue(success);
Condition condition=new DefaultCondition(null,null,null,null,startTime,endTime,null,null,true);
condition.setStatement(String.format(GET_METRIC_AGGREGATE_ONLY_SQL,PhoenixTransactSQL.getNaiveTimeRangeHint(startTime,NATIVE_TIME_RANGE_DELTA),METRICS_AGGREGATE_DAILY_TABLE_NAME));
PreparedStatement pstmt=PhoenixTransactSQL.prepareGetMetricsSqlStmt(conn,condition);
ResultSet rs=pstmt.executeQuery();
while (rs.next()) {
TimelineMetric currentMetric=readHelper.getTimelineMetricKeyFromResultSet(rs);
MetricHostAggregate currentHostAggregate=readHelper.getMetricHostAggregateFromResultSet(rs);
if ("disk_used".equals(currentMetric.getMetricName())) {
assertEquals(2.0,currentHostAggregate.getMax());
assertEquals(0.0,currentHostAggregate.getMin());
assertEquals(12 * 20,currentHostAggregate.getNumberOfSamples());
assertEquals(12 * 15.0,currentHostAggregate.getSum());
assertEquals(15.0 / 20,currentHostAggregate.getAvg());
}
}
}
Class: org.apache.hadoop.yarn.server.applicationhistoryservice.metrics.timeline.discovery.TestMetadataManager InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier cachedData=metadataManager.getMetadataCache();
Assert.assertNotNull(cachedData);
Assert.assertEquals(2,cachedData.size());
TimelineMetricMetadataKey key1=new TimelineMetricMetadataKey("dummy_metric1","dummy_app1");
TimelineMetricMetadataKey key2=new TimelineMetricMetadataKey("dummy_metric2","dummy_app2");
TimelineMetricMetadata value1=new TimelineMetricMetadata("dummy_metric1","dummy_app1","Integer",null,1L,true);
TimelineMetricMetadata value2=new TimelineMetricMetadata("dummy_metric2","dummy_app2","Integer",null,1L,true);
Assert.assertEquals(value1,cachedData.get(key1));
Assert.assertEquals(value2,cachedData.get(key2));
TimelineMetricMetadataSync syncRunnable=new TimelineMetricMetadataSync(metadataManager);
syncRunnable.run();
Map savedData=hdb.getTimelineMetricMetadata();
Assert.assertNotNull(savedData);
Assert.assertEquals(2,savedData.size());
Assert.assertEquals(value1,savedData.get(key1));
Assert.assertEquals(value2,savedData.get(key2));
Map> cachedHostData=metadataManager.getHostedAppsCache();
Map> savedHostData=metadataManager.getPersistedHostedAppsData();
Assert.assertEquals(cachedData.size(),savedData.size());
Assert.assertEquals("dummy_app1",cachedHostData.get("dummy_host1").iterator().next());
Assert.assertEquals("dummy_app2",cachedHostData.get("dummy_host2").iterator().next());
Assert.assertEquals("dummy_app1",savedHostData.get("dummy_host1").iterator().next());
Assert.assertEquals("dummy_app2",savedHostData.get("dummy_host2").iterator().next());
}
Class: org.apache.hadoop.yarn.server.applicationhistoryservice.timeline.TestLeveldbTimelineStore APIUtilityVerifier InternalCallVerifier EqualityVerifier primaryFilter=Collections.singletonMap("user",Collections.singleton((Object)"otheruser"));
TimelineEntities atsEntities=new TimelineEntities();
atsEntities.setEntities(Collections.singletonList(createEntity(entityId1b,entityType1,789l,Collections.singletonList(ev2),null,primaryFilter,null)));
TimelinePutResponse response=store.put(atsEntities);
assertEquals(0,response.getErrors().size());
NameValuePair pfPair=new NameValuePair("user","otheruser");
List entities=getEntitiesWithPrimaryFilter("type_1",pfPair);
assertEquals(1,entities.size());
verifyEntityInfo(entityId1b,entityType1,Collections.singletonList(ev2),EMPTY_REL_ENTITIES,primaryFilter,EMPTY_MAP,entities.get(0));
entities=getEntitiesWithPrimaryFilter("type_1",userFilter);
assertEquals(2,entities.size());
verifyEntityInfo(entityId1,entityType1,events1,EMPTY_REL_ENTITIES,primaryFilters,otherInfo,entities.get(0));
verifyEntityInfo(entityId1b,entityType1,events1,EMPTY_REL_ENTITIES,primaryFilters,otherInfo,entities.get(1));
((LeveldbTimelineStore)store).discardOldEntities(-123l);
assertEquals(1,getEntitiesWithPrimaryFilter("type_1",pfPair).size());
assertEquals(2,getEntitiesWithPrimaryFilter("type_1",userFilter).size());
((LeveldbTimelineStore)store).discardOldEntities(123l);
assertEquals(0,getEntities("type_1").size());
assertEquals(0,getEntities("type_2").size());
assertEquals(0,((LeveldbTimelineStore)store).getEntityTypes().size());
assertEquals(0,getEntitiesWithPrimaryFilter("type_1",pfPair).size());
assertEquals(0,getEntitiesWithPrimaryFilter("type_1",userFilter).size());
}
InternalCallVerifier EqualityVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.webapp.TestAHSWebApp APIUtilityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.webapp.TestAHSWebServices UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier UtilityVerifier InternalCallVerifier EqualityVerifier HybridVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier Class: org.apache.hadoop.yarn.server.applicationhistoryservice.webapp.TestTimelineWebServices InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier NullVerifier HybridVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier APIUtilityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier InternalCallVerifier EqualityVerifier